
# instalando algumas bibliotecas no servidor do Colab (Linux)
!apt-get install graphviz libgraphviz-dev pkg-config
!pip install txtoflow


# Importando a biblioteca txtoflow para gerar um fluxograma a partir de código
from txtoflow import txtoflow

# Definindo o pseudocódigo e passando-o como entrada para gerar o fluxograma
txtoflow.generate(
  '''
  Início;
  Abrir forno;
  if (forno aceso?) {
    Colocar lenha;
  } else {
    Acender fogo;
  }
  Assar pão;
  Fim;
  '''
)


# definindo uma variável do tipo texto (string) para armazenar o pseudocódigo
alg2 = '''
leia(A);
B = 10;
if ( A > 0 ) {
  escreva("'A' Positivo");
} else if ( A >- 10 ) {
  escreva("'A' Negativo: -10<A<=0");
  B = A;
  while ( B < 0 ) {
    B = B + 1;
  }
}
escreva("B=",B);
Fim;'''

# Criando o fluxograma
txtoflow.generate(alg2)


# instalações necessárias
!pip install --upgrade git+https://github.com/innovationOUtside/flowchart_js_jp_proxy_widget.git


from google.colab import output
output.enable_custom_widget_manager()


alg3 = '''
A = int(input())
B = 10
if A > 0:
  print("'A' Positivo")
elif A > -10:
  print("'A' Negativo: -10<A<=0")
  B = A
  while B < 0:
    B = B + 1
    print(B)
print("B=",B)'''


from pyflowchart import Flowchart
fc = Flowchart.from_code(alg3)
flowchart = fc.flowchart()


from jp_flowchartjs.jp_flowchartjs import FlowchartWidget

testEmbed = FlowchartWidget()
testEmbed.charter(flowchart)
testEmbed


idade = 20        # Este é um comentário
anoAtual = 2024;  # Observe que ';' é opcional em Python e JavaScript


idade


anoNascimento = anoAtual - idade
anoNascimento


nomeAluno = 'Rafael Morais'
nomeAluno


pi = 3.1415926535897932
pi


# Exemplos 1:
y=10
y*=2  # y recebe 10*2=20
y/=4  # y recebe 20/4=5.0 (float)
y**=2 # y recebe 5**2=25.0
y%=10 # y recebe 25%10=5.0
y


# Exemplos 2:
print("5 + 3 =", 5 + 3)
print("4 - 1 =", 4 - 1)
print("9 * 2 =", 9 * 2)
print("8 / 2 =", 8 / 2)
print("9 // 2 =", 9 // 2)
print("9 % 2 = ",  9 % 2)


# Exemplos 3:
i = 1
i += 2
print("i = 1, i += 2, i = ", i)

i = 5
i -= 1
print("i = 5, i -= 1, i = ", i)

i = 4
i *= 3
print("i = 4, i *= 3, i = ", i)

i = 6
i /= 2
print("i = 6, i /= 2, i = ", i)

print("3**4=", 3**4)

print("abs(-8)=",abs(-8))

print("pow(9,2) = ", pow(9,2))

print("round(1/9, 3) = ", round(1/9, 3))  # 1/9 = 0.1111111111111111


# Exemplos:
print("1 == 1", 1 == 1)
print("1 == 0", 1 == 0)
print("1 != 0", 1 != 0)
print("3 > 4 ", 3 > 4)
print("3 < 4 ", 3 < 4)
print("3 in [3,4] ", 3 in [3,4])


# Exemplos:
t = True
f = False


# Operador "and"
print(t and t)
print(t and f)
print(f and t)
print(f and f)


# Operador "or"
print(t or t)
print(t or f)
print(f or t)
print(f or f)


# Operador "not"
print(not t)
print(not f)


# Exemplos:
print( 2 ** 2 * 4 + 8 == 24)
print( 2 ** 2 * (4 + 8) == 24)

# Acho mais claro utilizar parenteses:
print( ( (2 ** 2) * 4) + 8 == 24)


# Exemplo: Tipos
idade = 23
print( type(idade) )

peso = 72.3
print( type(peso) )

aluno = True
print( type(aluno) )

nome = 'Rafael Morais'
print( type(nome) )

comp = 23 + 12j
print( type(comp) )
print( comp.real )
print( comp.imag )
print( comp.conjugate() )


# Exemplo: Conversores
idade = float(idade)
print(idade)
print(type(idade))

peso = int(peso)
print(peso)
print(type(peso))

idade = str(idade)
print(idade)
print(type(idade))


#para verificação
c,f,ano,idd=1,22,1994,0
ano=ano+idd
idd*=f
c+=1
ano+=f
f-=4
c+=1
print(c,f,ano,idd) # print é um comando de saída de dados


print('Alô, Mundo!')


%%writefile cap1ex01.py
print('Alô, Mundo!')


%%writefile cap1ex01.java
class cap1ex01 {
	public static void main (String[] args) {
    System.out.println("Alô, Mundo!");
	}
}


%%writefile cap1ex01.html
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title>UFABC</title>
    <script>
      // código em javascript
      var ola = 'Alô, Mundo!'
    </script>
  </head>
  <body>
    <script>
      document.write(ola)
    </script>
  </body>
</html>


%%writefile cap1ex01.py
print('Alô, Mundo!')


%%writefile cap1ex01.c
#include <stdio.h>
int main(void) {
  printf("Alô, Mundo!");
  return 0;
}


!gcc -Wall -std=c99 cap1ex01.c -o output2
!./output2


# activate R magic
%load_ext rpy2.ipython


%%writefile cap1ex01.r
cat('Alô, Mundo!')


!Rscript cap1ex01.r


# Para executar este arquivo Python dentro deste Colab, use o seguinte comando:
!python cap1ex01.py


%%shell
# Outra forma de executar este arquivo Python dentro deste Colab é usando o seguinte comando:
python cap1ex01.py


!apt-get install default-jre


!javac cap1ex01.java
!java cap1ex01


%%javascript
element.append("Alô, Mundo!");


%%writefile cap1ex01.js
console.log("Alô, Mundo!")


!node cap1ex01.js


%%html
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title>UFABC</title>
    <script>
      var message = "Alô, Mundo!"
    </script>
  </head>
  <body>
    <h1>Primeiro programa</h1>
    <script>
      document.querySelector("#output-area").appendChild(document.createTextNode(message));
    </script>
  </body>
</html>


# activate R magic
%load_ext rpy2.ipython


%%R
print("Alô, Mundo!")


A, B = 2, 3 # duas atribuições em uma única linha
C = (A+B) * 2
print(C)


A = input("Entre com o valor de A: ")
A = int(A)  # Necessário converter str para int
B = 3
C = 2 * (A + B)
print(C)


nota1 = int(input('Digite a nota 1: '))
nota2 = int(input('Digite a nota 2: '))
nota3 = int(input('Digite a nota 3: '))
media = (nota1 + nota2 + nota3) / 3
print('Média =', media)
print('Média = ' + str(media))  # ou
print('Média = %.1f' % (media))  # ou
print('Média = {}'.format(media))  # ou
print(f'Média = {media}')  # ou


%%writefile cap1ex02.py
C = int(input())  # ATENÇÃO NESTA INSTRUÇÃO!
F = C * 9/5 + 32
print(C, "graus Celsius corresponde a", F, "graus Fahrenheit")


%%writefile cap1ex02.java
import java.util.Scanner;
class cap1ex02 {
	public static void main (String[] args) {
    Scanner teclado1 = new Scanner(System.in);
    int C = teclado1.nextInt();
    float F = C * 9/5 + 32;
    System.out.println(C+" graus Celsius corresponde a "+F+" graus Fahrenheit");
	}
}


!javac cap1ex02.java
!java cap1ex02


%%html
<script>
  function calculate_this() {
  var input = document.getElementById('numbers').value;
  var results = eval(input);
  document.getElementById('results').innerHTML = results;
  }
</script>
Digite algo: <input type="text" id="numbers" value="2*2+1">
<input type=button value="Armazenar" onClick="calculate_this()"><br>
Result: <span id="results">(click "Armazenar")</span>


%%html
<script>
    function calculate_this() {
    var C = parseInt(document.getElementById('number1').value);
    var F = C * 9/5 + 32
    var results = C + " graus Celsius corresponde a " + F.toFixed(1) + " graus Fahrenheit"
    document.getElementById('results').innerHTML = results;
    }
</script>
Digite algo: <input type="text" id="number1" value="55">
<input type=button value="calcular" onClick="calculate_this()"><br>
Result: <span id="results">(click "calcular")</span>


%%writefile cap1ex02.js
var C = process.argv.slice(2)[0] // ATENÇÃO NESTA INSTRUÇÃO!
var F = C * 9/5 + 32
console.log(C + " graus Celsius corresponde a " + F.toFixed(1) + " graus Fahrenheit")


!node cap1ex02.js 65 33


%%writefile cap1ex02.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function ler(linhas,i) {return linhas.toString().split('\n')[i]}

process.stdin.once('data', linhas => {
    escreva("Entre com C: ")
    var C = ler(linhas,0) // ATENÇÃO NESTA INSTRUÇÃO!
    var F = C * 9/5 + 32
    escreva(C + " graus Celsius corresponde a " + F.toFixed(1) + " graus Fahrenheit")
})


# NÃO RODA NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap1ex02.js 65


%%shell
node


%%writefile cap1ex02.c
#include <stdio.h>
int main(void) {
  int C;
  scanf("%d", &C);
  float F = C * 9/5 + 32;
  printf("%d graus Celsius corresponde a %.1f graus Fahrenheit", C, F);
  return 0;
}


%%shell
gcc -Wall -std=c99 cap1ex02.c -o output2
./output2


# activate R magic
%load_ext rpy2.ipython


%%R
print("Entre com graus Celsius :")
C <- as.integer(readline(prompt = ""))
F <- C * 9/5 + 32;
cat(C, "graus Celsius corresponde a", F,  "graus Fahrenheit");


%%writefile cap1ex02.r
print("Entre com graus Celsius :")
C <- as.integer(readLines("stdin",n=1));
F <- C * 9/5 + 32;
cat(C, "graus Celsius corresponde a", format(F, nsmall = 1),  "graus Fahrenheit");


%%shell
Rscript cap1ex02.r


%%writefile cap1ex03.c
#include <stdio.h>
int main(void) {
  char ch;
  int i;
  long int li;
  short s;
  unsigned int ui;
  float f;
  double d;
  long double ld;

  printf("Numero de bytes por tipo de dados:\n");
  printf("char:         %ld\n", sizeof (ch));
  printf("int:          %ld\n", sizeof (i));
  printf("long int:     %ld\n", sizeof (li));
  printf("short:        %ld\n", sizeof (s));
  printf("unsigned int: %ld\n", sizeof (ui));
  printf("float:        %ld\n", sizeof (f));
  printf("double:       %ld\n", sizeof (d));
  printf("long double:  %ld\n", sizeof (ld));
  return 0;
}


%%shell
gcc -Wall -std=c99 cap1ex03.c -std=c99 -Wall -o output3
./output3


%%writefile cap1ex04.c
#include <stdio.h>
int main(void) {
  double d = 3.14;
  int i = (int)d; // AQUI ESTA O CAST
  printf("double = %f\n", d);
  printf("int = %d\n", i);
  return 0;
}


%%shell
gcc -Wall -std=c99 cap1ex04.c -std=c99 -Wall -o output4
./output4


import math
print("math.pi =", math.pi)
print("math.sqrt(25) =", math.sqrt(25))
print("5**3 ou math.pow(5,3) =", math.pow(5, 3))
print("math.exp(1) =", math.exp(1))
print("math.exp(2) =", math.exp(2))


!pip install matplotlib


import matplotlib.pyplot as plt
x1, y1 = 0, 0
x2, y2 = 6, 12

plt.title("meu primeiro gráfico")
plt.text(x1, y1, "p1", bbox=dict(facecolor='red', alpha=0.4), fontsize=12)
plt.text(x2, y2, "p2", bbox=dict(facecolor='red', alpha=0.4), fontsize=12)
plt.plot([x1, x2], [y1, y2], color='blue')
plt.grid()


# A função é definida aqui
def delta(a, b, c):
    d = b * b - 4 * a * c
    return d

# Agora já pode ser usada
valor = delta(5, -2, 4)
print("O delta de ax^2 + bx + c é %.1f" % valor)


%%writefile myBiblioteca.py
def Delta(a, b, c):
    '''
    Função para calcular o delta de uma equação de 2o. grau
    com coeficientes a, b e c
    '''
    d = b * b - 4 * a * c
    return d

def Raiz1(a, b, c):
    '''
    Função para calcular raiz1 de a, b e c
    '''
    r1 = (-b + Delta(a, b, c)**.5) / (2 * a)
    return r1

def Raiz2(a, b, c):
    '''
    Função para calcular raiz2 de a, b e c
    '''
    r2 = (-b - Delta(a, b, c)**.5) / (2 * a)
    return r2


import myBiblioteca as my
help(my)


my.Delta(1,5,4)


my.Raiz1(1,5,4)


my.Raiz2(1,5,4)


import matplotlib.pyplot as plt
import numpy as np

x = np.arange(-5, 0, 0.1)
a, b, c = 1, 5, 4
y1 = a * x * x + b * x + c
plt.plot(x, y1, 'g')
plt.title("Meu gráfico")
plt.text(my.Raiz2(1, 5, 4), 0, "r1", bbox=dict(facecolor='red', alpha=0.4), fontsize=12)
plt.text(my.Raiz1(1, 5, 4), 0, "r2", bbox=dict(facecolor='red', alpha=0.4), fontsize=12)
plt.grid()
plt.show()


from myBiblioteca import Delta # ou
from myBiblioteca import *
Delta(5,-2,4)


#https://drive.google.com/file/d/1x7uFa8lhaHUVG0mnCHc6PGbtTtMYrUn1/view?usp=drive_link
!pip install -U --no-cache-dir gdown --pre
!gdown --id 1x7uFa8lhaHUVG0mnCHc6PGbtTtMYrUn1


#https://www.ufabc.edu.br/images/conteudo/15-anos.png
!wget https://www.ufabc.edu.br/images/conteudo/15-anos.png


%%writefile cap2ex01.java
class cap2ex01 {
  public static void main(String[] args) {
    double a=5.0, b=-2.0, c=4.0;
    System.out.println("O delta de ax^2 + bx + c é " + delta(a, b, c));
  }
  public static double delta(double a, double b, double c){
    double d = b*b-4*a*c;
    return d;
  }
}


!javac cap2ex01.java
!java cap2ex01


%%writefile cap2ex01.js
function delta(a, b, c){
    var d = b*b-4*a*c;
    return d;
  }

var a=5.0, b=-2.0, c=4.0;
console.log("O delta de ax^2 + bx + c é " + delta(a,b,c).toFixed(1))


%%shell
node cap2ex01.js


%%shell
node


%%writefile cap2ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function delta(a, b, c){
  var d = b*b-4*a*c;
  return d;
}

var a=5.0, b=-2.0, c=4.0;
escreva("O delta de ax^2 + bx + c é " + delta(a,b,c).toFixed(1))
})


# NÃO RODA NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap2ex02 3 4 2


%%writefile cap2ex01.c
#include <stdio.h>
// MÉTODO

float delta(float a, float b, float c) {
  float d = b * b - 4 * a * c;
  return d;
}
// PROGRAMA PRINCIPAL
int main(void) {
  float a = 5.0, b = -2.0, c = 4.0;
  printf("O delta de ax^2 + bx + c e %.1f\n", delta(a, b, c));
  return 0;
}


%%shell
gcc -Wall -std=c99 cap2ex01.c -o output2
./output2


# activate R magic
%load_ext rpy2.ipython


%%R
delta <- function(a,b,c) {
  temp <- b*b-4*a*c;
  return(temp);
}
a <- 5.0
b <- -2.0
c <- 4.0
d <- delta(a,b,c)
cat("O delta de ax^2 + bx + c é ", format(d, nsmall = 1));


%%writefile cap2ex01.r
delta <- function(a,b,c) {
  temp <- b*b-4*a*c;
  return(temp);
}
a <- 5.0
b <- -2.0
c <- 4.0
d <- delta(a,b,c)
cat("O delta de ax^2 + bx + c é ", format(d, nsmall = 1));


%%shell
Rscript cap2ex01.r


def calculaIdade(anoAtual):
  global anoNascimento  # considera a variável global
  return anoAtual - anoNascimento

anoNascimento = 2005
print("Idade =", calculaIdade(2024))


def minha_funcao():
    global global_var  # experimente comentar essa linha
    global_var += 1 # incrementa uma variável global
    # minha_funcao()
    '''
    O que vai ocorrer se descomentar a linha anterior?
    Isso é recursão, mas faltou a condição de parada.
    Qual seria um exemplo de condição de parada?
    Resposta: próximo capítulo - condicional
    '''
    return global_var

global_var = 10
minha_funcao()


# DEFINIÇÕES DE FUNÇÕES:
def leia():
    a = float(input("Entre com o valor de a:"))
    b = float(input("Entre com o valor de b:"))
    c = float(input("Entre com o valor de c:"))
    return a, b, c

def escreva(d):
    print('Delta =', d)

def delta(a, b, c):
    d = b * b - 4 * a * c
    return d

# programa principal
# ENTRADA DE DADOS
a, b, c = leia()

# PROCESSAMENTO
d = delta(a, b, c)

# SAÍDA DE DADOS
escreva(d)


%%writefile cap2ex02.java
import java.util.Scanner;
class cap2ex02 {
  public static void main(String[] args) {
    // ENTRADAS
    double a, b, c, d;
    a = leia();
    b = leia();
    c = leia();

    // PROCESSAMENTO
    d = delta(a, b, c);

    // SAÍDA
    escreva(d);
  }

  public static double leia() {
    double valor;
    Scanner teclado1 = new Scanner(System.in);
    System.out.print("Entre com um valor: ");
    valor = teclado1.nextDouble();
    return valor;
  }

  public static void escreva(double valor) {
    System.out.println("Delta = " + valor);
  }

  public static double delta(double a, double b, double c) {
    double d = b * b - 4 * a * c;
    return d;
  }
}


!javac cap2ex02.java
!java cap2ex02


%%writefile cap2ex02.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString()}

function delta(a, b, c) {
  var d = b * b - 4 * a * c;
  return d;
}

process.stdin.once('data', linhas => {

    // ENTRADAS
    escreva("Entre com C: ")
    var a = leia(linhas,0) // ATENÇÃO NESTA INSTRUÇÃO!
    var b = leia(linhas,1) // ATENÇÃO NESTA INSTRUÇÃO!
    var c = leia(linhas,2) // ATENÇÃO NESTA INSTRUÇÃO!

    // PROCESSAMENTO
    var d = delta(a,b,c)

    // SAÍDA
    escreva("Delta = " + d.toFixed(1))
})


# NÃO RODA NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap2ex02 3 4 2


# solução 1
%%writefile cap2ex02.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
const leia = (name) => {return `${name}`}

function delta(a, b, c) {
  var d = b * b - 4 * a * c;
  return d;
}

# ENTRADAS
var a = leia(process.argv[2]) // ATENÇÃO NESTA INSTRUÇÃO!
var b = leia(process.argv[3]) // ATENÇÃO NESTA INSTRUÇÃO!
var c = leia(process.argv[4]) // ATENÇÃO NESTA INSTRUÇÃO!

# PROCESSAMENTO
var d = delta(a,b,c)

# SAÍDA
escreva("Delta = " + d.toFixed(1))


%%shell
node cap2ex02 5 3 -2


# solução 2
%%writefile cap2ex02.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
const leia = (name) => {return `${name}`}

function delta(a, b, c) {
  var d = b * b - 4 * a * c;
  return d;
}

# ENTRADAS
var a = process.argv.slice(2)[0] // ATENÇÃO NESTA INSTRUÇÃO!
var b = process.argv.slice(2)[1] // ATENÇÃO NESTA INSTRUÇÃO!
var c = process.argv.slice(2)[2] // ATENÇÃO NESTA INSTRUÇÃO!

# PROCESSAMENTO
var d = delta(a,b,c)

# SAÍDA
escreva("Delta = " + d.toFixed(1))


%%writefile cap2ex02.c
#include <stdio.h>

float delta(float a, float b, float c) {
  float d = b*b-4*a*c;
  return d;
}

float leia() {
  float valor;
  printf("Entre com um valor: ");
  scanf("%f", &valor);
  return valor;
}

int main(void) {

  // ENTRADAS
  float a, b, c, d;
  a = leia();
  b = leia();
  c = leia();

  // PROCESSAMENTO
  d = delta(a, b, c);

  //SAÍDA
  printf("Delta = %.1f", d);
  return 0;
}


%%shell
gcc -Wall -std=c99 cap2ex02.c -o output2
./output2


# activate R magic
%load_ext rpy2.ipython


%%R
delta <- function(a,b,c) {
  temp <- b*b-4*a*c;
  return(temp);
}

leia <- function() {
  cat("Entre com um valor :")
  valor <- as.numeric(readline(prompt = ""))
  return(valor);
}

escreva <- function(valor) {
  cat("Delta = ", format(valor, nsmall = 1));
}

# ENTRADAS
a <- leia()
b <- leia()
c <- leia()

# PROCESSAMENTO
d <- delta(a,b,c)

# SAÍDA
escreva(d)


# Para rodar SOMENTE em uma atividade no Moodle+VPL
%%writefile cap2ex02.r
delta <- function(a,b,c) {
  temp <- b*b-4*a*c;
  return(temp);
}

leia <- function() {
  print("Entre com um valor: ")
  valor <- as.numeric(readline(prompt = ""))
  return(valor);
}

escreva <- function(valor) {
  cat("Delta = ", format(valor, nsmall = 1));
}

# ENTRADAS
a <- leia()
b <- leia()
c <- leia()

# PROCESSAMENTO
d <- delta(a,b,c)

# SAÍDA
escreva(d)


%%shell
Rscript cap2ex02.r


def gorjeta(conta):
    global valor
    valor = conta + (conta * 0.10)

valor = 100
gorjeta(100)
print(f"O valor total gasto pelo cliente é de R${valor:.2f}")


!apt-get install graphviz libgraphviz-dev pkg-config
!pip install txtoflow


from txtoflow import txtoflow

txtoflow.generate(
    '''
    Início;
    if (Está Chovendo?) {
        Resolver Sudoku;
    } else {
        Andar de Bicicleta;
    }
    Fim;
    '''
)


X, Y, Z = 1, 2, 4
equacao1 = (X>0 and Y<2)
equacao2 = (Z>0 or Z<5 and Y==4)
equacao3 = (X>>1 ==0 or Y<<2>100)
equacao4 = (X!=0 and Y!=0 and Z<0)
#equacao5 = (X=1) # ERRO de sintaxe, deveria ser X==1
print(equacao1,equacao2,equacao3,equacao4)


# Exemplo de uso do operador ">>" (shift à direita)
# O número 6 em binário é 1 1 0, que pode ser representado como 1*2^2 + 1*2^1 + 0*2^0

# Agora, aplicamos o operador de deslocamento à direita (">>") por 1 posição
resultado = 6 >> 1  # O resultado será 3
resultado
# Em binário, 3 é representado como 0 1 1 (1*2^1 + 1*2^0)


def delta( a, b, c ):
  return b * b - 4 * a * c;

# ENTRADA DE DADOS
print("Calcula as raízes de equação de 2º grau na forma ax^2 + bx + c")
a = float(input("Entre com o primeiro termo a:"))
b = float(input("Entre com o segundo  termo b:"))
c = float(input("Entre com o terceiro termo c:"))

# PROCESSAMENTO E SAÍDA
d = delta(a,b,c)
print("O delta é ", d)
if d< 0:
  print("A equação não possui raízes reais.")
if d==0:
  print("A raíz é ", -b +d**(1/2.0) / (2*a))
if d>0:
  print("Raízes:",-b-d**(1/2.0)/(2*a),",",-b+d**(1/2.0)/(2*a))


%%writefile cap3ex01.java
class cap3ex01 {

    public static void main(String[] args) {

        // ENTRADA DE DADOS
        escreva("Resolve equação de 2º grau: ax^2 + bx + c\n");
        double a = leia("Entre com o primeiro termo 'a': ");
        double b = leia("Entre com o segundo  termo 'b': ");
        double c = leia("Entre com o terceiro termo 'c': ");

        // PROCESSAMENTO E SAÍDA
        double d = delta(a, b, c);
        String res = "O delta é " + d + "\n";
        if (d < 0) {
            res += "A equação não possui raízes reais";
        }
        if (d == 0) {
            res += "Raíz: " + (-b + Math.sqrt(d) / 2 * a);
        }
        if (d > 0) {
            res += "Raízes: "
                    + (-b - Math.sqrt(d) / 2 * a) + " e "
                    + (-b + Math.sqrt(d) / 2 * a);
        }
        escreva(res + ".\n"); // exibe sentença e pula linha
    }

    public static double delta(double a, double b, double c) {
        return b * b - 4 * a * c;
    }

    public static float leia(Object texto) {
        System.out.print(texto);
        return new java.util.Scanner(System.in).nextFloat();
    }

    static void escreva(Object o) {
        System.out.print(o);
    }
}


!javac cap3ex01.java
!java cap3ex01


# solução 1
%%writefile cap3ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
const leia = (name) => {return `${name}`}

function delta(a, b, c) {
  var d = b * b - 4 * a * c;
  return d;
}

// ENTRADAS
var a = leia(process.argv[2]) // ATENÇÃO NESTA INSTRUÇÃO!
var b = leia(process.argv[3]) // ATENÇÃO NESTA INSTRUÇÃO!
var c = leia(process.argv[4]) // ATENÇÃO NESTA INSTRUÇÃO!

// PROCESSAMENTO E SAÍDA
var d = delta(a, b, c);
var res = "O delta é " + d.toFixed(1) + "\n";
if (d < 0) {
    res += "A equação não possui raízes reais";
}
if (d == 0) {
    res += "Raíz: " + (-b + Math.sqrt(d) / 2 * a);
}
if (d > 0) {
    res += "Raízes: "
            + (-b - Math.sqrt(d) / 2 * a) + " e "
            + (-b + Math.sqrt(d) / 2 * a);
}
escreva(res + ".\n"); // exibe sentença e pula linha


%%shell
node cap3ex01.js 4 5 2


# solução 2 para executar no Moodle+VPL
%%writefile cap3ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString()}

function delta(a, b, c) {
  var d = b * b - 4 * a * c;
  return d;
}

process.stdin.once('data', linhas => {

  // ENTRADAS
  var a = leia(process.argv[2]) // ATENÇÃO NESTA INSTRUÇÃO!
  var b = leia(process.argv[3]) // ATENÇÃO NESTA INSTRUÇÃO!
  var c = leia(process.argv[4]) // ATENÇÃO NESTA INSTRUÇÃO!

  // PROCESSAMENTO E SAÍDA
  var d = delta(a, b, c);
  var res = "O delta é " + d.toFixed(1) + "\n";
  if (d < 0) {
      res += "A equação não possui raízes reais";
  }
  if (d == 0) {
      res += "Raíz: " + (-b + Math.sqrt(d) / 2 * a);
  }
  if (d > 0) {
      res += "Raízes: "
              + (-b - Math.sqrt(d) / 2 * a) + " e "
              + (-b + Math.sqrt(d) / 2 * a);
  }
  escreva(res + ".\n"); // exibe sentença e pula linha
})


# NÃO EXECUTA NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap3ex01.js 4 5 2


%%writefile cap3ex01.c
#include <stdio.h>
#include <math.h>
float delta(float a, float b, float c) {
  float d = b*b-4*a*c;
  return d;
}

float leia() {
  float valor;
  printf("Entre com um valor: ");
  scanf("%f", &valor);
  return valor;
}

int main(void) {

  // ENTRADAS
  float a, b, c;
  a = leia();
  b = leia();
  c = leia();

  // PROCESSAMENTO e SAÍDA
  double d = (double) delta(a, b, c);
  printf("Delta = %.1f\n", d);
  if (d < 0) {
      printf("A equação não possui raízes reais");
  }
  if (d == 0) {
      printf("Raíz: %.1f",(-b + sqrt(d) / 2 * a));
  }
  if (d > 0) {
      printf("Raíz: %.1f e %.1f ",(-b - sqrt(d) / 2 * a), (-b + sqrt(d) / 2 * a));
  }
  return 0;
}


%%shell
gcc -Wall -std=c99 cap3ex01.c -o output2 -lm
./output2
# A biblioteca matemática deve ser vinculada ao construir o executável.
# Como fazer isso varia de acordo com o ambiente,
# mas no Linux / Unix, basta adicionar -lm ao comando


# activate R magic
%load_ext rpy2.ipython


%%R
delta <- function(a,b,c) {
  temp <- b*b-4*a*c;
  return(temp);
}

leia <- function() {
  cat("Entre com um valor :")
  valor <- as.numeric(readline(prompt = ""))
  return(valor);
}

# ENTRADAS
a <- leia()
b <- leia()
c <- leia()

# PROCESSAMENTO e SAÍDA
d <- delta(a,b,c)
cat("Delta = ", format(d, nsmall = 1), '\n');

if (d < 0) {
    cat("A equação não possui raízes reais");
}
if (d == 0) {
    cat("Raíz: ",(-b + sqrt(d) / 2 * a));
}
if (d > 0) {
    cat("Raíz: ",(-b - sqrt(d) / 2 * a)," e ", (-b + sqrt(d) / 2 * a));
}


# Para executar SOMENTE em uma atividade no Moodle+VPL
%%writefile cap3ex01.r
delta <- function(a,b,c) {
  temp <- b*b-4*a*c;
  return(temp);
}

leia <- function() {
  cat("Entre com um valor: ")
  valor <- as.numeric(readline(prompt = ""))
  return(valor);
}

# ENTRADAS
a <- leia()
b <- leia()
c <- leia()

# PROCESSAMENTO e SAÍDA
d <- delta(a,b,c)
cat("Delta = ", format(d, nsmall = 1), '\n');

if (d < 0) {
    cat("A equação não possui raízes reais");
}
if (d == 0) {
    cat("Raíz: ",(-b + sqrt(d) / 2 * a));
}
if (d > 0) {
    cat("Raíz: ",(-b - sqrt(d) / 2 * a)," e ", (-b + sqrt(d) / 2 * a));
}


%%shell
#Rscript cap3ex01.r


from txtoflow import txtoflow

txtoflow.generate(
    '''
    Início;
    Leia nota1;
    Leia nota2;
    Média = (nota1+nota2)/2;
    if ( media >= 9 ) {
        escreva("Conceito A");
    } else if (media >= 7.5 ) {
        escreva("Conceito B");
    } else if (media >= 6 ) {
        escreva("Conceito C");
    } else if (media >= 5 ) {
        escreva("Conceito D");
    } else {
        escreva("Conceito F");
    }
    Fim;
    '''
)


# a função é definida aqui
def leia():
  a = float(input("Digite a 1a nota: "))
  b = float(input("Digite a 2a nota: "))
  return a,b;

# programa principal
# ENTRADA
nota1,nota2 = leia()

# PROCESSAMENTO E SAÍDA
media = (nota1 + nota2)/2

if media >= 9:
  print("Conceito A")
elif media >= 7.5:
  print("Conceito B");
elif media >= 6:
  print("Conceito C")
elif media >= 5:
  print("Conceito D")
else:
  print("Reprovado! Conceito F")


%%writefile cap3ex02.java
import java.util.Scanner;
class cap3ex02 {
  public static void main(String[] args) {

    // ENTRADAS
    Scanner teclado1 = new Scanner(System.in);
    float nota1 = teclado1.nextFloat();
    float nota2 = teclado1.nextFloat();

    // PROCESSAMENTO E SAÍDA
    float media = (nota1 + nota2)/2;
    if (media >= 9.0)
      System.out.print("Conceito A");
    else if (media >= 7.5)
      System.out.print("Conceito B");
    else if (media >= 6.0)
      System.out.print("Conceito C");
    else if (media >= 5.0)
      System.out.print("Conceito D");
    else
      System.out.print("Reprovado! Conceito F.");
  }
}


!javac cap3ex02.java
!java cap3ex02


# Para executar no Moodle+VPL
%%writefile cap3ex02.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

process.stdin.once('data', linhas => {

    // ENTRADAS
    var nota1 = parseFloat(leia(linhas,0)) // ATENÇÃO NESTA INSTRUÇÃO!
    var nota2 = parseFloat(leia(linhas,1)) // ATENÇÃO NESTA INSTRUÇÃO!

    // PROCESSAMENTO e SAÍDA
    var media = (nota1 + nota2)/2;
    if (media >= 9.0)
      escreva("Conceito A");
    else if (media >= 7.5)
      escreva("Conceito B");
    else if (media >= 6.0)
      escreva("Conceito C");
    else if (media >= 5.0)
      escreva("Conceito D");
    else
      escreva("Reprovado! Conceito F.");
})


%%shell
#node cap3ex02 3 4 2


%%writefile cap3ex02.c
#include <stdio.h>
float leia() {
  float valor;
  printf("Entre com um valor: ");
  scanf("%f", &valor);
  return valor;
}

int main(void) {

  // ENTRADAS
  float nota1 = leia();
  float nota2 = leia();

  // PROCESSAMENTO E SAÍDA
  float media = (nota1 + nota2)/2;
  if (media >= 9.0)
    printf("Conceito A");
  else if (media >= 7.5)
    printf("Conceito B");
  else if (media >= 6.0)
    printf("Conceito C");
  else if (media >= 5.0)
    printf("Conceito D");
  else
    printf("Reprovado! Conceito F.");
  return 0;
}


%%shell
gcc -Wall -std=c99 cap3ex02.c -o output2
./output2


# activate R magic
%load_ext rpy2.ipython


%%R
leia <- function() {
  print("Entre com um valor :")
  valor <- as.numeric(readline(prompt = ""))
  return(valor);
}

# ENTRADAS
nota1 <- leia()
nota2 <- leia()

# PROCESSAMENTO e SAÍDA
media <- (nota1 + nota2)/2;

if (media >= 9.0) {
  cat("Conceito A");
} else if (media >= 7.5) {
  cat("Conceito B");
} else if (media >= 6.0) {
  cat("Conceito C");
} else if (media >= 5.0) {
  cat("Conceito D");
} else
  cat("Reprovado! Conceito F.");


# Para executar SOMENTE em uma atividade no Moodle+VPL
%%writefile cap2ex02.r
# ENTRADAS
lines <- readLines(con = file("stdin"))
nota1 <- as.numeric(lines[1])
nota2 <- as.numeric(lines[2])

# PROCESSAMENTO e SAÍDA
media <- (nota1 + nota2)/2;

if (media >= 9.0) {
  cat("Conceito A");
} else if (media >= 7.5) {
  cat("Conceito B");
} else if (media >= 6.0) {
  cat("Conceito C");
} else if (media >= 5.0) {
  cat("Conceito D");
} else
  cat("Reprovado! Conceito F.");


%%shell
Rscript cap2ex02.r


%%writefile cap3ex03.c
#include <stdio.h>
int main() {
  float area;
  int num;
  char escolha;
  printf("1. Circulo\n");
  printf("2. Quadrado\n");
  printf("Escolha:\n");

  scanf("%c", &escolha);

  switch (escolha) {
  case '1':
    printf("Raio:\n");
    scanf("%d", &num);
    area = 3.14 * num * num;
    printf("Area do circulo: ");
    printf("%.2f\n", area);
    break;

  case '2':
    printf("Lado:\n");
    scanf("%d", &num);
    area = num * num;
    printf("Area do quadrado: ");
    printf("%.2f\n", area);
    break;

  default:
    printf("Escolha Incorreta!\n");
  }
  return 0;
}


%%shell
gcc -Wall -std=c99 cap3ex03.c -o output3
./output3


!apt-get install graphviz libgraphviz-dev pkg-config
!pip install txtoflow


from txtoflow import txtoflow

txtoflow.generate(
    '''
    Início;
    acumulador = 0, contador = 0, resposta == 's';
    while (resposta == 's') {
      escreva("Digite uma nota entre 0 e 10:");
      leia(nota);
      acumulador += nota;
      contador++;
      resposta = leia("Deseja continuar? (s/n): ");
    }
    media = acumulador / contador;
    escreva("A média é ", media, "de", contador, "notas");
    Fim;
    '''
)


!apt-get install graphviz libgraphviz-dev pkg-config
!pip install txtoflow


from txtoflow import txtoflow

txtoflow.generate(
    '''
    Início;
    acumulador = 0, contador = 0, resposta == 's';
    while (resposta == 's') {
      escreva("Digite uma nota entre 0 e 10:");
      leia(nota);
      while (nota < 0 or nota > 10) {
        escreva("ERRO, nota inválida. Digite uma nota entre 0 e 10:");
        leia(nota);
      }
      acumulador += nota;
      contador++;
      resposta = leia("Deseja continuar? (s/n): ");
    }
    media = acumulador / contador;
    escreva("A média é ", media, "de", contador, "notas");
    Fim;
    '''
)


!apt-get install graphviz libgraphviz-dev pkg-config
!pip install txtoflow


from txtoflow import txtoflow

txtoflow.generate(
    '''
    Início;
    acumulador = 0, contador = 0;
    escreva("Entre com 10 notas válidas");
    while (contador<10) {
      leia(nota);
      while (nota < 0 or nota > 10) {
        escreva("ERRO, nota inválida. Digite uma nota entre 0 e 10:");
        leia(nota);
      }
      acumulador = acumulador + nota;
      contador++;
    }
    media = acumulador / contador;
    escreva("A média é ", media);
    Fim;
    '''
)


# ENTRADA DE DADOS e PROCESSAMENTO
acumulador, contador = 0,0
print("Entre com 10 notas válidas")
while (contador<10):
  nota = float(input())
  if nota<0 or nota>10:
    print("ERRO, nota inválida. Digite uma nota entre 0 e 10:");
    continue
  acumulador += nota
  contador += 1

media = acumulador/contador

# SAÍDA
print("A média das " + str(contador) + " notas é " + str(round(media,1)))


%%writefile cap4ex01.java
import java.util.Scanner;
class cap4ex01 {
  public static void main(String[] args) {

    // ENTRADA DE DADOS e PROCESSAMENTO
    float acumulador = 0, nota, media;
    int contador = 0;
    Scanner teclado1 = new Scanner(System.in);

    System.out.println("Entre com 10 notas válidas");
    while (contador<10) {
      do {
          nota = teclado1.nextFloat();
      } while (nota < 0 || nota > 10 );
      acumulador += nota;
      contador++;
    }
    media = acumulador/contador;
    // SAÍDA
    System.out.print("A média das " + contador + " notas é " + media);
  }
}


!javac cap4ex01.java
!java cap4ex01


%%writefile cap4ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

process.stdin.once('data', linhas => {

  // ENTRADA e PROCESSAMENTO
  escreva("Entre com 10 notas válidas");
  var contador = 0
  var acumulador = 0
  var contaLinhas = 0

  while (contador<10) {
    do {
        nota = parseFloat(leia(linhas,contaLinhas)) // ATENÇÃO NESTA INSTRUÇÃO!
        contaLinhas++;
    } while (nota < 0 || nota > 10 );
    acumulador += nota;
    contador++;
  }
  var media = acumulador/contador;
  // SAÍDA
  escreva("A média das " + contador + " notas é " + media.toFixed(1));
})


# NÃO EXECUTA NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap3ex01.js 4 5 2


%%writefile cap4ex01.c
#include <stdio.h>

int main(void) {

  // ENTRADA DE DADOS e PROCESSAMENTO
  float acumulador = 0, nota, media;
  int contador = 0;

  printf("Entre com 10 notas válidas\n");
  while (contador<10) {
    do {
        scanf("%f", &nota);
    } while (nota < 0.0 || nota > 10.0 );
    acumulador = acumulador + nota;
    contador++;
  }
  media = acumulador/contador;

  // SAÍDA
  printf("A média das %d notas é %.1f\n", contador, media);

  return 0;
}


%%shell
gcc -Wall -std=c99 cap4ex01.c -o output
./output


# activate R magic
%load_ext rpy2.ipython


%%writefile cap4ex01.r
acumulador <- 0
contador <- 0
cat("Entre com 10 notas válidas");
while (contador < 10) {
  repeat {
    nota <- as.numeric(readline(prompt = "")) # ATENÇÃO
    if ((nota >= 0 && nota <= 10)) {
      break
    }
  }
  acumulador <- acumulador + nota;
  contador <- contador + 1;
}
media <- acumulador/contador;
# SAÍDA
cat("A média das ", contador, " notas é ", format(media, nsmall = 1))


# Para executar SOMENTE em uma atividade no Moodle+VPL
%%writefile cap4ex01.r
acumulador <- 0
contador <- 0
cat("Entre com 10 notas válidas\n");
con <- file("stdin")    # ATENÇÃO
lines <- readLines(con) # ATENÇÃO
contaLinhas <- 1        # ATENÇÃO
while (contador<10) {
  repeat {
    nota <- as.numeric(lines[contaLinhas]) # ATENÇÃO
    contaLinhas <- contaLinhas + 1         # ATENÇÃO
    if ((nota >= 0 && nota <= 10)) {
      break
    }
  }
  acumulador <- acumulador + nota;
  contador <- contador + 1;
}
media <- acumulador/contador;
close(con)                                 # ATENÇÃO
# SAÍDA
cat("A média das ", contador, " notas é ", format(media, nsmall = 1))


!Rscript cap4ex01.r


def fatorial(n):
    if n == 1: # critério de parada
        return 1
    fi = fatorial(n-1)
    return n * fi

n = int(input("Entre com um número: "))
print("Fatorial de", n, "é", fatorial(n))


%%writefile cap4ex02.java
import java.util.Scanner;

public class cap4ex02 {
    public static int fatorial(int n) {
        if (n == 1) { // critério de parada
            return 1;
        }
        return n * fatorial(n-1);
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Entre com um número: ");
        int n = input.nextInt();
        input.close();

        System.out.println("Fatorial de " + n + " é " + fatorial(n));
    }
}


!javac cap4ex02.java
!java cap4ex02


%%writefile cap4ex02.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

process.stdin.once('data', linhas => {

  function fatorial(n) {
    if (n == 1) { // critério de parada
      return 1;
    }
    return n * fatorial(n-1);
  }

  // ENTRADA e PROCESSAMENTO
  escreva("Entre com um número: ");
  var n = parseInt(leia(linhas,contaLinhas)) // ATENÇÃO NESTA INSTRUÇÃO!

  // SAÍDA
  escreva("Fatorial de " + n + " é " + fatorial(n));
})


# NÃO EXECUTA NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap3ex02.js 4


%%writefile cap4ex02.c
#include <stdio.h>

int fatorial(int n) {
  long int f;
  printf("debug - antes  - n = %d\n",n);
  if (n == 1) f = 1; // CRITÉRIO DE PARADA!!!
  else // CHAMADA RECURSIVA, COM ALTERAÇÃO DO VALOR DO ARGUMENTO!!!
    f = n * fatorial(n-1);
  printf("debug - depois - n = %d; fatorial = %ld\n", n, f);
  return f;
}

int main(void) {
  // ENTRADA DE DADOS e PROCESSAMENTO
  int n;

  printf("Entre com n: ");
  scanf("%d", &n);

  // PROCESSAMENTO E SAÍDA
  printf("Fatorial de %d é %d\n", n, fatorial(n));

  return 0;
}


%%shell
gcc -Wall -std=c99 cap4ex02.c -o output
./output


# activate R magic
%load_ext rpy2.ipython


%%writefile cap4ex02.r
fatorial <- function(n) {
  if (n == 1) { # critério de parada
    return(1)
  }
  return(n * fatorial(n-1))
}

n <- readline(prompt = "Entre com um número: ")
n <- as.integer(n)

# SAÍDA
cat("Fatorial de", n, "é", fatorial(n))


!Rscript cap4ex02.r


def lerNota(acumulador, n):
    nota = float(input("Digite uma nota: "))
    if nota < 0 or nota > 10:
        return lerNota(acumulador, n)
    elif n > 1:
        return lerNota(acumulador + nota, n - 1)
    else:
        return acumulador + nota

contador = 10
print("Entre com", contador, "notas válidas")
acumulador = lerNota(0, contador)

media = acumulador / contador
print("A média das", contador, "notas é", media)


%%writefile cap4ex03.java
import java.util.Scanner;

public class cap4ex03 {
  public static void main(String[] args) {
    int contador = 10;
    Scanner sc = new Scanner(System.in);
    double acumulador = 0;
    System.out.println("Entre com " + contador + " notas válidas:");
    acumulador = lerNota(acumulador, contador);
    double media = acumulador / contador;
    System.out.println("A média das " + contador + " notas é " + media);
  }

  public static double lerNota(double acumulador, int n) {
    Scanner sc = new Scanner(System.in);
    double nota;
    if (n > 0) { // CRITÉRIO DE PARADA
      do {
        System.out.println("Digite uma nota entre 0 e 10:");
        nota = sc.nextDouble();
      } while (nota < 0 || nota > 10);
      return lerNota(acumulador + nota, n - 1); // CHAMADA RECURSIVA, COM ALTERAÇÃO DO VALOR DO ARGUMENTO !!!
    }
    return acumulador;
  }
}


!javac cap4ex03.java
!java cap4ex03


%%writefile cap4ex03.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

function lerNota(acumulador, n) {
  let nota;
  if (n > 0) { // CRITÉRIO DE PARADA
    do {
      nota = parseFloat(leia("Digite uma nota entre 0 e 10:"));
    } while (nota < 0 || nota > 10);
    return lerNota(acumulador + nota, n - 1); // CHAMADA RECURSIVA, COM ALTERAÇÃO DO VALOR DO ARGUMENTO !!!
  }
  return acumulador;
}

let acumulador = 0;
let contador = 10;
escreva("Entre com " + contador + " notas válidas\n");
acumulador = lerNota(acumulador, contador);
let media = acumulador / contador;
escreva("A média das " + contador + " notas é " + media);


# NÃO EXECUTA NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap3ex03.js 4


%%writefile cap4ex03.c
#include <stdio.h>

float lerNota(float acumulador, int n) {
  float nota;
  if (n > 0) { // CRITÉRIO DE PARADA!!!
    do {
      scanf("%f", &nota);
    } while (nota < 0.0 || nota > 10.0);
    // CHAMADA RECURSIVA, COM ALTERAÇÃO DO VALOR DO ARGUMENTO!!!
    acumulador = lerNota(acumulador, n - 1);
  }
  return acumulador + nota;
}

int main(void) {

  // ENTRADA DE DADOS e PROCESSAMENTO
  float acumulador = 0, media;
  int contador = 10;

  printf("Entre com %d notas válidas\n", contador);

  // CHAMADA RECURSIVA
  acumulador = lerNota(acumulador, contador);

  media = acumulador / contador; // MÉDIA

  // SAÍDA
  printf("A média das %d notas é %.1f\n", contador, media);

  return 0;
}


%%shell
gcc -Wall -std=c99 cap4ex03.c -o output
./output


def Fibonacci(n):
    if n < 2: # CRITÉRIO DE PARADA
        return n
    else:
        return Fibonacci(n-2) + Fibonacci(n-1)

n = int(input("Entre com número: "))
resultado = Fibonacci(n)
print("Fibonacci de", n, "é", resultado)


%%writefile cap4ex04.java
import java.util.Scanner;

public class cap4ex04 {

  public static int Fibonacci(int n) {
    if (n < 2) { // CRITÉRIO DE PARADA
      return n;
    }
    return Fibonacci(n-2) + Fibonacci(n-1);
  }

  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("Entre com um número: ");
    int n = scanner.nextInt();
    scanner.close();
    System.out.println("Fibonacci de " + n + " é " + Fibonacci(n));
  }
}


!javac cap4ex04.java
!java cap4ex04


%%writefile cap4ex04.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

function Fibonacci(n) {
  if (n < 2) { // CRITÉRIO DE PARADA
    return n;
  }
  return Fibonacci(n-2) + Fibonacci(n-1);
}

let n = parseInt(leia("Entre com um número:"));
escreva("Fibonacci de " + n + " é " + Fibonacci(n));


# NÃO EXECUTA NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap3ex04.js 4


%%writefile cap4ex04.c
#include <stdio.h>

long int conta_recursao = 0;

int Fibonacci(int n) {
  long int f;
  printf("debug - antes   n = %d\n",n);
  if (n < 2) f = n; // CRITÉRIO DE PARADA!!!
  else // CHAMADA RECURSIVA, COM ALTERAÇÃO DO VALOR DO ARGUMENTO!!!
    f = Fibonacci(n-2) + Fibonacci(n-1);
  conta_recursao++;
  printf("debug - depois  n = %d \t Fibonacci(%d) = %ld \t conta = %ld\n", n, n, f, conta_recursao);
  return f;
}

int main(void) {
  // ENTRADA DE DADOS e PROCESSAMENTO
  int n;

  printf("Entre com n: ");
  scanf("%d", &n);

  // PROCESSAMENTO E SAÍDA
  printf("Fibonacci de %d é %d\n", n, Fibonacci(n));

  return 0;
}


%%shell
gcc -Wall -std=c99 cap4ex04.c -o output
./output


#format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]


print('{0}, {1}, {2}'.format('a', 'b', 'c'))
print('{}, {}, {}'.format('a', 'b', 'c'))  # 3.1+ only
print('{2}, {1}, {0}'.format('a', 'b', 'c'))
print('{2}, {1}, {0}'.format(*'abc'))      # unpacking argument sequence
print('{0}{1}{0}'.format('abra', 'cad'))   # arguments' indices can be repeated


'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')


coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
'Coordinates: {latitude}, {longitude}'.format(**coord)


c = 3-5j
('The complex number {0} is formed from the real part {0.real} and the imaginary part {0.imag}.').format(c)


class Point:
     def __init__(self, x, y):
         self.x, self.y = x, y
     def __str__(self):
         return 'Point({self.x}, {self.y})'.format(self=self)

str(Point(4, 2))


coord = (3, 5)
'X: {0[0]};  Y: {0[1]}'.format(coord)


"repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')


'{:<30}'.format('left aligned')


'{:>30}'.format('right aligned')


'{:^30}'.format('centered')


'{:*^30}'.format('centered')  # use '*' as a fill char


'{:+f}; {:+f}'.format(3.14, -3.14)  # show it always


'{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers


'{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'


"int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)


"int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)


'{:,}'.format(1234567890)


points = 19
total = 22
'Correct answers: {:.2%}'.format(points/total)


import datetime
d = datetime.datetime(2010, 7, 4, 12, 15, 58)
'{:%Y-%m-%d %H:%M:%S}'.format(d)


v1 = [0,0,0,0,0]  # vetor de inteiros iniciado com zero ou
v2 = [0]*100      # vetor de inteiros com 100 elementos, iniciado com zero
v3 = [4,1,10,2,3]
print(v3)         # ou
print(*v3)


# ENTRADA DE DADOS
# Solicitar ao usuário o número de alunos
n = int(input("Digite o número de alunos:"))

# Inicializar vetores vazios para armazenar RA (números inteiros) e nomes (strings)
ra = []  # vetor vazio de inteiros
nome = []  # vetor vazio de strings

# Preencher os vetores com dados fornecidos pelo usuário
for i in range(n):
    ra.append(int(input("RA:")))
    nome.append(input("Nome:"))

# PROCESSAMENTO: Neste exemplo, não há processamento adicional.

# SAÍDA DE DADOS: Apresentar a lista de alunos formatada
print("LISTA DE ALUNOS\nNúmero\t RA\t Nome")
for i in range(n):
    print(i + 1, "\t", ra[i], "\t", nome[i])


%%writefile cap5ex01.java
import java.util.Scanner;
public class cap5ex01 {
    public static void main(String[] args) {
        // ENTRADA DE DADOS
        System.out.print("Digite o numero de alunos: ");
        Scanner scan = new Scanner(System.in);
        Scanner scan1 = new Scanner(System.in); // ATENÇÃO
        int n = scan.nextInt();        // lê número de elementos
        Integer ra[] = new Integer[n]; // declara e aloca memória
        String nome[] = new String[n]; // declara e aloca memória

        for (int i = 0; i < n; i++) {
            System.out.print("RA: ");
            ra[i] = scan.nextInt();
            System.out.print("Nome: ");
            nome[i] = scan1.nextLine(); // ATENÇÃO
        }
        // PROCESSAMENTO ?
        // SAÍDA DE DADOS
        System.out.println("LISTA DE ALUNOS\nNúmero\t RA\t Nome");
        for (int i = 0; i < n; i++) {
            System.out.println(i + 1 + "\t " + ra[i] + "\t" + nome[i]);
        }
    }
}


!javac cap5ex01.java
!java cap5ex01


# solução 1
%%writefile cap5ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
const leia = (name) => {return `${name}`}

// ENTRADAS
escreva("Digite o numero de alunos: ")
var n = parseInt(leia(process.argv[2]))    // ATENÇÃO NESTA INSTRUÇÃO!
var ra = [];
var nome = [];
contaLinhas = 3;
for (i=0; i<n; i++) {
    ra[i] = parseInt(leia(process.argv[contaLinhas])) // ATENÇÃO NESTA INSTRUÇÃO!
    nome[i] = leia(process.argv[contaLinhas+1])       // ATENÇÃO NESTA INSTRUÇÃO!
    contaLinhas = contaLinhas + 2
}
// PROCESSAMENTO ?
// SAÍDA DE DADOS
escreva("LISTA DE ALUNOS\nNúmero\t RA\tNome")
for (i=0; i<n; i++) {
    escreva(i + 1 + "\t " + ra[i] + "\t" + nome[i])
}


%%shell
node cap5ex01 2 23 ANA 433 "MARIA Julia"


# solução 2: para executar no Moodle+VPL
%%writefile cap5ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

process.stdin.once('data', linhas => {
  // ENTRADAS
  escreva("Digite o numero de alunos: ")
  var n = parseInt(leia(linhas,0))    // ATENÇÃO NESTA INSTRUÇÃO!
  var ra = [];
  var nome = [];
  contaLinhas = 1;
  for (i=0; i<n; i++) {
      ra[i] = parseInt(leia(linhas,contaLinhas)) // ATENÇÃO NESTA INSTRUÇÃO!
      nome[i] = leia(linhas,contaLinhas+1)       // ATENÇÃO NESTA INSTRUÇÃO!
      contaLinhas = contaLinhas + 2
  }
  // PROCESSAMENTO ?
  // SAÍDA DE DADOS
  escreva("LISTA DE ALUNOS\nNúmero\t RA\tNome")
  for (i=0; i<n; i++) {
      escreva(i + 1 + "\t " + ra[i] + "\t" + nome[i])
  }
})


# NÃO executa NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap5ex01.js 4 5 2


%%writefile cap5ex01.c
#include <stdio.h>

int main(void) {

  // ENTRADA DE DADOS
  int max = 100; // considerar sempre um número grande
  int n, ra[max];     // aloca 100 ra's
  char nome[max][40]; // aloca 100 nomes de até 40 caracteres cada

  printf("Digite o numero de alunos: ");
  scanf("%d", &n);
  for (int i = 0; i < n; i++) {
    printf("RA: ");
    scanf("%d", &ra[i]);
    printf("Nome: ");
    scanf("%s", nome[i]); // ATENÇÃO: NÃO ACEITA NOME COM ESPAÇOS e NÃO USA &
  }
  // PROCESSAMENTO ?
  // SAÍDA
  printf("LISTA DE ALUNOS\nNúmero\t RA\t Nome\n");
  for (int i = 0; i < n; i++) {
    printf("%d\t %d\t %s\n", i + 1, ra[i], nome[i]);
  }
  return 0;
}


%%shell
gcc -Wall -std=c99 cap5ex01.c -o output2
./output2


%%writefile cap5ex01teste.c
#include <stdio.h>
#include <string.h>

int main() {
   char s[40];
   printf("digite algo:\n");
   fgets(s, 40, stdin);
   printf("saida: \"%s\" tamanho: %ld\n", s, strlen(s));
   s[strlen(s)-1] = '\0'; // substituir \n por \0
   printf("saida: \"%s\" tamanho: %ld\n", s, strlen(s));
   return 0;
}


%%shell
gcc -Wall -std=c99 cap5ex01teste.c -o cap5ex01teste
./cap5ex01teste


# activate R magic
%load_ext rpy2.ipython


%%R
# ENTRADA DE DADOS
cat("Digite o numero de alunos: ");
n <- as.numeric(readline(prompt = "")) # ATENÇÃO
ra <- NULL
nome <- NULL

for(i in 1:n){
  cat("RA: ")
  x <-  as.numeric(readline(prompt = "")) # ATENÇÃO
  ra <- c(ra, x)
  cat("Nome: ")
  x <-  readline(prompt = "") # ATENÇÃO
  nome <- c(nome, x)
}

# PROCESSAMENTO ?
# SAÍDA
cat("LISTA DE ALUNOS\nNúmero\t RA\t Nome\n");
for(i in 1:n){
  cat(i,"\t",ra[i],"\t",nome[i],"\n")
}


# MÉTODO(S)
def leiaVetor(n):
    """
    Método para ler um vetor de tamanho n.

    Parameters:
    n (int): Número de elementos do vetor.

    Returns:
    list: Vetor lido.
    """
    vetor = []  # cria uma lista/vetor vazia
    for i in range(n):
        elemento = int(input("Digite um valor: "))  # solicita um novo elemento para o usuário
        vetor.append(elemento)  # insere o novo elemento na lista/vetor
    return vetor

# ENTRADA DE DADOS
numero_alunos = int(input("Digite o número de alunos:"))
print(f"Entre com {numero_alunos} RAs:")
ras = leiaVetor(numero_alunos)
print(f"Entre com {numero_alunos} Notas:")
notas = leiaVetor(numero_alunos)

# PROCESSAMENTO
# Neste exemplo, não há processamento adicional explícito.

# SAÍDA DE DADOS
print("LISTA DE ALUNOS")
print("Número\t RA\t Nota")
for i in range(numero_alunos):
    print(i + 1, "\t", ras[i], "\t", notas[i])


%%writefile cap5ex02.java
import java.util.Scanner;

public class cap5ex02 {

    static Scanner scan = new Scanner(System.in);

    public static void main(String[] args) {

        System.out.print("Digite o numero de alunos:");
        int n = scan.nextInt();        // lê número de elementos
        int ras[]; // declara
        int notas[]; // declara

        System.out.println("Entre com " + n + " RAs:");
        ras = leiaVetor(n);
        System.out.println("Entre com " + n + " Notas:");
        notas = leiaVetor(n);

        // PARA VERIFICAÇÃO
        //System.out.println("RA's:");
        //escrevaVetor(ras);
        //System.out.println("Notas:");
        //escrevaVetor(notas);

        System.out.println("LISTA DE ALUNOS\nNúmero\tRA\tNota");
        for (int i = 0; i < n; i++) {
            System.out.println(i + 1 + "\t" + ras[i] + "\t" + notas[i]);
        }
    }

    static int[] leiaVetor(int n) {
        // leitura dos n elmentos do vetor v1
        int[] v = new int[n]; // declara e aloca
        for (int i = 0; i < v.length; i++) {
            //System.out.print("Digite um numero inteiro  " + i + ": ");
            v[i] = scan.nextInt();
        }
        return v;
    }

    static void escrevaVetor(int v[]) {
        for (int i = 0; i < v.length; i++) {
            System.out.println(v[i]);
        }
        System.out.println();
    }
}


!javac cap5ex02.java
!java cap5ex02


# solução 1
%%writefile cap5ex02.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
const leia = (name) => {return `${name}`}

function leiaVetor(n,contaLinhas) {
    var v = [];
    for (i=0; i<n; i++) {
      v[i] = parseInt(leia(process.argv[contaLinhas])) // ATENÇÃO NESTA INSTRUÇÃO!
      contaLinhas++
    }
    return v
}
// ENTRADAS
escreva("Digite o numero de alunos: ")
var n = parseInt(leia(process.argv[2]))    // ATENÇÃO NESTA INSTRUÇÃO!
var ras = [];
var notas = [];
contaLinhas = 3;
ras = leiaVetor(n,contaLinhas)
contaLinhas += n
notas = leiaVetor(n,contaLinhas)

// PROCESSAMENTO ?
// SAÍDA DE DADOS
escreva("LISTA DE ALUNOS\nNúmero\t RA\tNota")
for (i=0; i<n; i++) {
    escreva(i + 1 + "\t " + ras[i] + "\t" + notas[i])
}


%%shell
node cap5ex02 2 2345 3456 5 9


# solução 2: para executar no Moodle+VPL
%%writefile cap5ex02.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

function leiaVetor(linhas,n,contaLinhas) {
    var v = [];
    for (i=0; i<n; i++) {
      v[i] = parseInt(leia(linhas,contaLinhas)) // ATENÇÃO NESTA INSTRUÇÃO!
      contaLinhas++
    }
    return v
}

process.stdin.once('data', linhas => {
  // ENTRADAS
  escreva("Digite o numero de alunos: ")
  var n = parseInt(leia(linhas,0))    // ATENÇÃO NESTA INSTRUÇÃO!
  var ras = [];
  var notas = [];
  contaLinhas = 1;
  ras = leiaVetor(linhas,n,contaLinhas)
  contaLinhas += n
  notas = leiaVetor(linhas,n,contaLinhas)

  // PROCESSAMENTO ?
  // SAÍDA DE DADOS
  escreva("LISTA DE ALUNOS\nNúmero\t RA\tNota")
  for (i=0; i<n; i++) {
      escreva(i + 1 + "\t " + ras[i] + "\t" + notas[i])
  }
})


# NÃO executa NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap5ex02 2 2345 3456 5 9


%%writefile cap5ex02.c
#include <stdio.h>

int main(void) {

  // ENTRADA DE DADOS
  int max = 100; // número máximo de alunos
  int n, ras[max], notas[max];   // variaveis de referência ras e notas

  printf("Digite o numero de alunos: \n");
  scanf("%d", &n);

  printf("RAs: \n");
  for (int i = 0; i < n; i++) {
    printf("RA %d: \n", i + 1);
    scanf("%d", &ras[i]);
  }

  printf("Notas: \n");
  for (int i = 0; i < n; i++) {
    printf("Nota %d: \n", i + 1);
    scanf("%d", &notas[i]);
  }

  // PROCESSAMENTO ?
  // SAÍDA
  printf("LISTA DE ALUNOS\nNúmero\t RA\t Nota\n");
  for (int i = 0; i < n; i++) {
    printf("%d\t %d\t %d\n", i + 1, ras[i], notas[i]);
  }
  return 0;
}


%%shell
gcc -Wall -std=c99 cap5ex02.c -o output2
./output2


%%writefile cap5ex02teste1.c
#include <stdio.h>

#define MAX_ALUNOS 20 // número máximo de alunos

void leiaVetor(int *v, int n) {
  for (int i = 0; i < n; i++)
    scanf("%d", &v[i]);
}

int main(void) {

  // ENTRADA DE DADOS
  int n, ras[MAX_ALUNOS], notas[MAX_ALUNOS];   // variaveis de referência ras e notas

  printf("Digite o numero de alunos: \n");
  scanf("%d", &n);

  printf("RAs: \n");
  leiaVetor(ras, n);

  printf("Notas: \n");
  leiaVetor(notas, n);

  // PROCESSAMENTO ?
  // SAÍDA
  printf("LISTA DE ALUNOS\nNúmero\t RA\t Nota\n");
  for (int i = 0; i < n; i++)
    printf("%d\t %d\t %d\n", i + 1, ras[i], notas[i]);

  return 0;
}


%%shell
gcc -Wall -std=c99 cap5ex02teste1.c -o output2
./output2


%%writefile cap5ex02teste2.c
#include <stdio.h>
#include <stdlib.h>  // malloc e free

int * leiaVetor(int n) {
  int *v= malloc(sizeof(n));  // ALOCAÇÃO DINÂMICA
  for (int i = 0; i < n; i++) {
    scanf("%d", &v[i]);
  }
  return v;
}

int main(void) {

  // ENTRADA DE DADOS
  int n, *ras, *notas;   // variaveis de referência ras e notas

  printf("Digite o numero de alunos: ");
  scanf("%d", &n);

  printf("RAs: ");
  ras = leiaVetor(n);

  printf("Notas: ");
  notas = leiaVetor(n);

  // PROCESSAMENTO ?
  // SAÍDA
  printf("LISTA DE ALUNOS\nNúmero\t RA\t Nota\n");
  for (int i = 0; i < n; i++) {
      printf("%d\t %d\t %d\n",i+1, ras[i],notas[i]);
  }
  free(ras);   // LIBERAR MEMÓRIA ALOCADA COM malloc
  free(notas);
  return 0;
}


%%shell
gcc -Wall -std=c99 cap5ex02teste2.c -o output2
./output2


# activate R magic
%load_ext rpy2.ipython


%%R
leiaVetor <- function(n) {
  v <- NULL
  for(i in 1:n){
    x <-  as.numeric(readline(prompt = "")) # ATENÇÃO
    v <- c(v, x)
  }
  return(v);
}

# ENTRADA DE DADOS
cat("Digite o numero de alunos: ");
n <- as.numeric(readline(prompt = "")) # ATENÇÃO

cat("RAs: ")
ras <- leiaVetor(n)
cat("Notas: ")
notas <- leiaVetor(n)

# PROCESSAMENTO ?
# SAÍDA
cat("LISTA DE ALUNOS\nNúmero\t RA\t Nota\n");
for(i in 1:n){
  cat(i,"\t",ras[i],"\t",notas[i],"\n")
}


# Para executar SOMENTE em uma atividade no Moodle+VPL
%%writefile cap5ex02.r

leiaVetor <- function(contaLinhas,n) {
  v <- NULL
  for(i in 1:n){
    x <-  as.numeric(lines[contaLinhas]) # ATENÇÃO
    contaLinhas <- contaLinhas + 1
    v <- c(v, x)
  }
  return(v);
}

con <- file("stdin")    # ATENÇÃO
lines <- readLines(con) # ATENÇÃO
contaLinhas <- 1        # ATENÇÃO

# ENTRADA DE DADOS
cat("Digite o numero de alunos: ");
n <- as.numeric(lines[contaLinhas]) # ATENÇÃO
contaLinhas <- contaLinhas + 1

cat("RAs: ")
ras <- leiaVetor(contaLinhas,n)
contaLinhas <- contaLinhas + n
cat("Notas: ")
notas <- leiaVetor(contaLinhas,n)

# PROCESSAMENTO ?
# SAÍDA
cat("LISTA DE ALUNOS\nNúmero\t RA\t Nota\n");
for(i in 1:n){
  cat(i,"\t",ras[i],"\t",notas[i],"\n")
}


# MÉTODO(S)
def leiaVetor(n):
    """
    Método para ler um vetor de tamanho n.

    Parameters:
    n (int): Número de elementos do vetor.

    Returns:
    list: Vetor lido.
    """
    vetor = []  # cria uma lista/vetor vazia
    for i in range(n):
        elemento = int(input("Digite um valor: "))  # solicita um novo elemento para o usuário
        vetor.append(elemento)  # insere o novo elemento na lista/vetor
    return vetor

# ENTRADA DE DADOS
numero_alunos = int(input("Digite o número de alunos:"))
print(f"Entre com {numero_alunos} RAs:")
ras = leiaVetor(numero_alunos)
print(f"Entre com {numero_alunos} Notas:")
notas = leiaVetor(numero_alunos)

# PROCESSAMENTO
somador = 0
for i in range(numero_alunos):
    somador += notas[i]

media = somador / numero_alunos

contador = 0
for i in range(numero_alunos):
    if notas[i] >= media:
        contador += 1

# SAÍDA DE DADOS
print("Média da turma =", media)
print("Número de alunos acima ou igual à média =", contador)
print("LISTA DE ALUNOS ACIMA OU IGUAL À MÉDIA")
print("RA\t Nota")
for i in range(numero_alunos):
    if notas[i] >= media:
        print(ras[i], "\t", notas[i])


%%writefile cap5ex03.java

import java.util.Scanner;

public class cap5ex03 {

    static Scanner scan = new Scanner(System.in);

    public static void main(String[] args) {

        // ENTRADA DE DADOS
        System.out.print("Digite o numero de alunos:");
        int n = scan.nextInt();        // lê número de elementos
        int ras[];   // declara
        int notas[]; // declara
        int somador = 0, contador = 0;
        float media;

        System.out.println("Entre com " + n + " RAs:");
        ras = leiaVetor(n);
        System.out.println("Entre com " + n + " Notas:");
        notas = leiaVetor(n);


        // PROCESSAMENTO: soma, média e contador
        for (int i = 0; i < notas.length; i++) {
            somador = somador + notas[i];   // soma
        }
        media = (float) somador / n;            // média

        for (int i = 0; i < notas.length; i++) {
            if (notas[i] >= media) {        // conta alunos>=media
                contador = contador + 1;
            }
        }
        // SAÍDA:
        System.out.println("Média da turma = " + media);
        System.out.println("Número de alunos acima da média = " + contador);
        System.out.println("LISTA DE ALUNOS ACIMA DA MÉDIA\nRA\tNota");
        for (int i = 0; i < n; i++) {
            if (notas[i] >= media) {        // conta alunos>=media
              System.out.println(ras[i] + "\t" + notas[i]);
            }
        }
    }

    static int[] leiaVetor(int n) {
        // leitura dos n elementos do vetor v1
        int[] v = new int[n]; // declara e aloca
        for (int i = 0; i < v.length; i++) {
            //System.out.print("Digite um numero inteiro  " + i + ": ");
            v[i] = scan.nextInt();
        }
        return v;
    }
}


!javac cap5ex03.java
!java cap5ex03


# solução 1
%%writefile cap5ex03.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
const leia = (name) => {return `${name}`}

function leiaVetor(n,contaLinhas) {
    var v = [];
    for (i=0; i<n; i++) {
      v[i] = parseInt(leia(process.argv[contaLinhas])) // ATENÇÃO NESTA INSTRUÇÃO!
      contaLinhas++
    }
    return v
}

// ENTRADAS
escreva("Digite o numero de alunos: ")
var n = parseInt(leia(process.argv[2]))    // ATENÇÃO NESTA INSTRUÇÃO!
var ras = [];
var notas = [];
contaLinhas = 3;
somador = 0
contador = 0

ras = leiaVetor(n,contaLinhas)
contaLinhas += n
notas = leiaVetor(n,contaLinhas)

// PROCESSAMENTO: soma, média e contador
for (i = 0; i < n; i++) {
    somador = somador + notas[i];   // soma
}
media = somador / n; // média

for (i = 0; i < n; i++) {
    if (notas[i] >= media) {        // conta alunos>=media
        contador = contador + 1;
    }
}

// SAÍDA DE DADOS
escreva("Média da turma = " + media);
escreva("Número de alunos acima da média = " + contador);
escreva("LISTA DE ALUNOS ACIMA DA MÉDIA\nRA\tNota");
for (i=0; i<n; i++) {
  if (notas[i] >= media) {
    escreva(ras[i] + "\t" + notas[i])
  }
}


%%shell
node cap5ex03 2 2345 3456 6 9


# solução 2: para executar no Moodle+VPL
%%writefile cap5ex03.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

function leiaVetor(linhas,n,contaLinhas) {
    var v = [];
    for (i=0; i<n; i++) {
      v[i] = parseInt(leia(linhas,contaLinhas)) // ATENÇÃO NESTA INSTRUÇÃO!
      contaLinhas++
    }
    return v
}

process.stdin.once('data', linhas => {
  // ENTRADAS
  escreva("Digite o numero de alunos: ")
  var n = parseInt(leia(linhas,0))    // ATENÇÃO NESTA INSTRUÇÃO!
  var ras = [];
  var notas = [];
  contaLinhas = 1;
  somador = 0
  contador = 0

  ras = leiaVetor(linhas,n,contaLinhas)
  contaLinhas += n
  notas = leiaVetor(linhas,n,contaLinhas)

  // PROCESSAMENTO: soma, média e contador
  for (i = 0; i < n; i++) {
      somador = somador + notas[i];   // soma
  }
  media = somador / n; // média

  for (i = 0; i < n; i++) {
      if (notas[i] >= media) {        // conta alunos>=media
          contador = contador + 1;
      }
  }

  // SAÍDA DE DADOS
  escreva("Média da turma = " + media);
  escreva("Número de alunos acima da média = " + contador);
  escreva("LISTA DE ALUNOS ACIMA DA MÉDIA\nRA\tNota");
  for (i=0; i<n; i++) {
    if (notas[i] >= media) {
      escreva(ras[i] + "\t" + notas[i])
    }
  }
})


# NÃO executa NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap5ex03 2 2345 3456 5 9


# solução 1
%%writefile cap3ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
const leia = (name) => {return `${name}`}

// ENTRADAS
escreva("Digite o numero de alunos: ")
var n = parseInt(leia(process.argv[2]))    // ATENÇÃO NESTA INSTRUÇÃO!
var ra = [];
var nome = [];
contaLinhas = 3;
for (i=0; i<n; i++) {
    ra[i] = parseInt(leia(process.argv[contaLinhas])) // ATENÇÃO NESTA INSTRUÇÃO!
    nome[i] = leia(process.argv[contaLinhas+1])       // ATENÇÃO NESTA INSTRUÇÃO!
    contaLinhas = contaLinhas + 2
}
// PROCESSAMENTO ?
// SAÍDA DE DADOS
escreva("LISTA DE ALUNOS\nNúmero\t RA\tNome")
for (i=0; i<n; i++) {
    escreva(i + 1 + "\t " + ra[i] + "\t" + nome[i])
}


%%shell
node cap3ex01 2 23 ANA 433 "MARIA Julia"


# solução 2: para executar no Moodle+VPL
%%writefile cap5ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

process.stdin.once('data', linhas => {
  // ENTRADAS
  escreva("Digite o numero de alunos: ")
  var n = parseInt(leia(linhas,0))    // ATENÇÃO NESTA INSTRUÇÃO!
  var ra = [];
  var nome = [];
  contaLinhas = 1;
  for (i=0; i<n; i++) {
      ra[i] = parseInt(leia(linhas,contaLinhas)) // ATENÇÃO NESTA INSTRUÇÃO!
      nome[i] = leia(linhas,contaLinhas+1)       // ATENÇÃO NESTA INSTRUÇÃO!
      contaLinhas = contaLinhas + 2
  }
  // PROCESSAMENTO ?
  // SAÍDA DE DADOS
  escreva("LISTA DE ALUNOS\nNúmero\t RA\tNome")
  for (i=0; i<n; i++) {
      escreva(i + 1 + "\t " + ra[i] + "\t" + nome[i])
  }
})


# NÃO executa NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap5ex01.js 4 5 2


%%writefile cap5ex03.c
#include <stdio.h>
#include <stdlib.h>

int * leiaVetor(int n) {
  int *v= malloc(sizeof(n));
  for (int i = 0; i < n; i++) {
    scanf("%d", &v[i]);
  }
  return v;
}

int main(void) {

  // ENTRADA DE DADOS
  int n, *ras, *notas;   // variaveis de referência ras e notas
  float media,somador = 0.0;
  int contador = 0;

  printf("Digite o numero de alunos: ");
  scanf("%d", &n);

  printf("RAs: ");
  ras = leiaVetor(n);

  printf("Notas: ");
  notas = leiaVetor(n);

  // PROCESSAMENTO: soma, média e contador
  for (int i = 0; i < n; i++) {
      somador = somador + notas[i];   // soma
  }
  media = (float) somador / n;            // média

  for (int i = 0; i < n; i++) {
      if (notas[i] >= media) {        // conta alunos>=media
          contador = contador + 1;
      }
  }
  // SAÍDA DE DADOS
  printf("Média da turma = %.1f\n",media);
  printf("Número de alunos acima da média = %d\n",contador);
  printf("LISTA DE ALUNOS ACIMA DA MÉDIA\nRA\t Nota\n");
  for (int i = 0; i < n; i++) {
    if (notas[i] >= media) {        // conta alunos>=media
      printf("%d\t %d\n",ras[i],notas[i]);
    }
  }
  free(ras);  // liberar memória alocado com malloc
  free(notas);
  return 0;
}


%%shell
gcc -Wall -std=c99 cap5ex03.c -o output2
./output2


# activate R magic
%load_ext rpy2.ipython


%%R
leiaVetor <- function(n) {
  v <- NULL
  for(i in 1:n){
    x <-  as.numeric(readline(prompt = "")) # ATENÇÃO
    v <- c(v, x)
  }
  return(v);
}

# ENTRADA DE DADOS
cat("Digite o numero de alunos: ");
n <- as.numeric(readline(prompt = "")) # ATENÇÃO

cat("RAs: ")
ras <- leiaVetor(n)
cat("Notas: ")
notas <- leiaVetor(n)

# PROCESSAMENTO: soma, média e contador
somador <- 0
for(i in 1:n){
  somador <- somador + notas[i];   # soma
}
media <- somador / n;            # média

contador <- 0
for(i in 1:n){
  if (notas[i] >= media) {        # conta alunos>=media
      contador <- contador + 1;
  }
}
# SAÍDA DE DADOS
cat("Média da turma = ",media,"\n");
cat("Número de alunos acima da média = ",contador,"\n");
cat("LISTA DE ALUNOS ACIMA DA MÉDIA\nRA\t Nota\n");
for(i in 1:n){
  cat(ras[i],"\t",notas[i],"\n")
}


# Para executar SOMENTE em uma atividade no Moodle+VPL
%%writefile cap5ex03.r

leiaVetor <- function(contaLinhas,n) {
  v <- NULL
  for(i in 1:n){
    x <-  as.numeric(lines[contaLinhas]) # ATENÇÃO
    contaLinhas <- contaLinhas + 1
    v <- c(v, x)
  }
  return(v);
}

con <- file("stdin")    # ATENÇÃO
lines <- readLines(con) # ATENÇÃO
contaLinhas <- 1        # ATENÇÃO

# ENTRADA DE DADOS
cat("Digite o numero de alunos: ");
n <- as.numeric(lines[contaLinhas]) # ATENÇÃO
contaLinhas <- contaLinhas + 1

cat("RAs: ")
ras <- leiaVetor(contaLinhas,n)
contaLinhas <- contaLinhas + n
cat("Notas: ")
notas <- leiaVetor(contaLinhas,n)

# PROCESSAMENTO: soma, média e contador
somador <- 0
for(i in 1:n){
  somador <- somador + notas[i];   # soma
}
media <- somador / n;            # média

contador <- 0
for(i in 1:n){
  if (notas[i] >= media) {        # conta alunos>=media
      contador <- contador + 1;
  }
}
# SAÍDA DE DADOS
cat("Média da turma = ",media,"\n");
cat("Número de alunos acima da média = ",contador,"\n");
cat("LISTA DE ALUNOS ACIMA DA MÉDIA\nRA\t Nota\n");
for(i in 1:n){
  if (notas[i] >= media) {        # conta alunos>=media
      cat(ras[i],"\t",notas[i],"\n")
  }
}


# MÉTODOS
def leiaVetor(n):
    """
    Método para ler um vetor de tamanho n.

    Parameters:
    n (int): Número de elementos do vetor.

    Returns:
    list: Vetor lido.
    """
    vetor = []  # cria uma lista/vetor vazia
    for i in range(n):
        elemento = int(input("Entre com o elemento " + str(i) + ": "))  # solicita um novo elemento para o usuário
        vetor.append(elemento)  # insere o novo elemento na lista/vetor
    return vetor

def escrevaVetor(v):
    """
    Método para imprimir os elementos de um vetor.

    Parameters:
    v (list): Vetor a ser impresso.
    """
    for i in range(len(v)):
        print(v[i])

# ENTRADA DE DADOS
n = int(input("Digite o tamanho do vetor:"))
print(f"Entre com {n} elementos:")
v1 = leiaVetor(n)

v2 = [0]*n

# PROCESSAMENTO
for i in range(n):
    max_valor = v1[i]
    if i - 1 >= 0 and max_valor < v1[i - 1]:
        max_valor = v1[i - 1]
    if i + 1 < n and max_valor < v1[i + 1]:
        max_valor = v1[i + 1]
    v2[i] = max_valor

# SAÍDA DE DADOS
print('v2:')
escrevaVetor(v2)


%%writefile cap5ex04.java

import java.util.Scanner;

public class cap5ex04 {

    static Scanner scan = new Scanner(System.in);

    public static void main(String[] args) {

        // ENTRADA DE DADOS
        System.out.print("Digite o tamanho do vetor:");
        int n = scan.nextInt();        // lê número de elementos
        int v1[]; // declara

        System.out.println("Entre com " + n + " elementos:");
        v1 = leiaVetor(n);

        int[] v2 = new int[n]; // declara e aloca

        // PROCESSAMENTO
        for (int i = 0; i < v1.length; i++) {
          int max = v1[i];
          if (i-1 >= 0 && max < v1[i-1])
              max = v1[i-1];
          if (i+1 < n && max < v1[i+1])
              max = v1[i+1];
          v2[i] = max;
        }
        // SAÍDA:
        System.out.println("v2:");
        escrevaVetor(v2);
    }

    static int[] leiaVetor(int n) {
      // leitura dos n elementos do vetor v1
      int[] v = new int[n]; // declara e aloca
      for (int i = 0; i < v.length; i++) {
          //System.out.print("Digite um numero inteiro  " + i + ": ");
          v[i] = scan.nextInt();
      }
      return v;
    }
    static void escrevaVetor(int v[]) {
      for (int i = 0; i < v.length; i++) {
          System.out.println(v[i]);
      }
      System.out.println();
    }
}


!javac cap5ex04.java
!java cap5ex04


# solução 1
%%writefile cap5ex04.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
const leia = (name) => {return `${name}`}

function leiaVetor(n,contaLinhas) {
    var v = [];
    for (i=0; i<n; i++) {
      v[i] = parseInt(leia(process.argv[contaLinhas])) // ATENÇÃO NESTA INSTRUÇÃO!
      contaLinhas++
    }
    return v
}

function escrevaVetor(v) {
    for (i=0; i<v.length; i++) {
      escreva(v[i])
    }
}

// ENTRADAS
escreva("Digite o numero de elementos: ")
var n = parseInt(leia(process.argv[2]))    // ATENÇÃO NESTA INSTRUÇÃO!
contaLinhas = 3;

var v1 = leiaVetor(n,contaLinhas)

var v2 = new Array(n); // create an empty array with length n

// PROCESSAMENTO
for (i = 0; i < v1.length; i++) {
  max = v1[i];
  if (i-1 >= 0 && max < v1[i-1])
      max = v1[i-1];
  if (i+1 < n && max < v1[i+1])
      max = v1[i+1];
  v2[i] = max;
}
// SAÍDA:
escreva("v2:");
escrevaVetor(v2);


%%shell
node cap5ex04 3 -99 4 23


# solução 1: para executar no Moodle+VPL
%%writefile cap5ex03.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

function leiaVetor(linhas,n,contaLinhas) {
    var v = [];
    for (i=0; i<n; i++) {
      v[i] = parseInt(leia(linhas,contaLinhas)) // ATENÇÃO NESTA INSTRUÇÃO!
      contaLinhas++
    }
    return v
}

function escrevaVetor(v) {
    for (i=0; i<v.length; i++) {
      escreva(v[i])
    }
}

process.stdin.once('data', linhas => {
  // ENTRADAS
  escreva("Digite o tamanho do vetor: ")
  var n = parseInt(leia(linhas,0))    // ATENÇÃO NESTA INSTRUÇÃO!

  contaLinhas = 1;

  var v1 = leiaVetor(linhas,n,contaLinhas)

  var v2 = new Array(n); // create an empty array with length n


  // PROCESSAMENTO
  for (i = 0; i < v1.length; i++) {
    max = v1[i];
    if (i-1 >= 0 && max < v1[i-1])
        max = v1[i-1];
    if (i+1 < n && max < v1[i+1])
        max = v1[i+1];
    v2[i] = max;
  }
  // SAÍDA
  escreva("v2:");
  escrevaVetor(v2);

})


# NÃO executa NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap5ex03 2 2345 3456 5 9


# solução 2
%%writefile cap3ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
const leia = (name) => {return `${name}`}

// ENTRADAS
escreva("Digite o numero de alunos: ")
var n = parseInt(leia(process.argv[2]))    // ATENÇÃO NESTA INSTRUÇÃO!
var ra = [];
var nome = [];
contaLinhas = 3;
for (i=0; i<n; i++) {
    ra[i] = parseInt(leia(process.argv[contaLinhas])) // ATENÇÃO NESTA INSTRUÇÃO!
    nome[i] = leia(process.argv[contaLinhas+1])       // ATENÇÃO NESTA INSTRUÇÃO!
    contaLinhas = contaLinhas + 2
}
// PROCESSAMENTO ?
// SAÍDA DE DADOS
escreva("LISTA DE ALUNOS\nNúmero\t RA\tNome")
for (i=0; i<n; i++) {
    escreva(i + 1 + "\t " + ra[i] + "\t" + nome[i])
}


%%shell
node cap3ex01 2 23 ANA 433 "MARIA Julia"


# solução 2: para executar no Moodle+VPL
%%writefile cap5ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

process.stdin.once('data', linhas => {
  // ENTRADAS
  escreva("Digite o numero de alunos: ")
  var n = parseInt(leia(linhas,0))    // ATENÇÃO NESTA INSTRUÇÃO!
  var ra = [];
  var nome = [];
  contaLinhas = 1;
  for (i=0; i<n; i++) {
      ra[i] = parseInt(leia(linhas,contaLinhas)) // ATENÇÃO NESTA INSTRUÇÃO!
      nome[i] = leia(linhas,contaLinhas+1)       // ATENÇÃO NESTA INSTRUÇÃO!
      contaLinhas = contaLinhas + 2
  }
  // PROCESSAMENTO ?
  // SAÍDA DE DADOS
  escreva("LISTA DE ALUNOS\nNúmero\t RA\tNome")
  for (i=0; i<n; i++) {
      escreva(i + 1 + "\t " + ra[i] + "\t" + nome[i])
  }
})


# NÃO executa NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap5ex01.js 4 5 2


%%writefile cap5ex04.c
#include <stdio.h>
#include <stdlib.h>  // malloc e free

int * leiaVetor(int n) {
  int *v = malloc(n*sizeof(int));
  for (int i = 0; i < n; i++) {
    scanf("%d", &v[i]);
  }
  return v;
}
void escrevaVetor(int *v, int n) {
  for (int i = 0; i < n; i++) {
    printf("%d\n", v[i]);
  }
}
int main(void) {
  // ENTRADA DE DADOS
  int n, *v1;   // variaveis de referência v1
  printf("Digite o tamanho do vetor: ");
  scanf("%d", &n);
  int *v2 = malloc(100*sizeof(int));
  printf("Digite os elementos: ");
  v1 = leiaVetor(n);
  // PROCESSAMENTO
  for (int i = 0; i < n; i++) {
    int max = v1[i];
    if (i-1 >= 0 && max < v1[i-1])
        max = v1[i-1];
    if (i+1 < n && max < v1[i+1])
        max = v1[i+1];
    v2[i] = max;
  }
  // SAÍDA:
  printf("\nv2:\n");
  escrevaVetor(v2,n);
  free(v1); // liberar memória alocado com malloc
  free(v2);
  return 0;
}


%%shell
gcc -Wall -std=c99 cap5ex04.c -o output2
./output2


# activate R magic
%load_ext rpy2.ipython


%%R
leiaVetor <- function(n) {
  v <- NULL
  for(i in 1:n){
    x <-  as.integer(readline(prompt = "")) # ATENÇÃO
    v <- c(v, x)
  }
  return(v);
}

escrevaVetor <- function(v) {
  for(i in 1:length(v)){
    cat(v[i],"\n")
  }
}

# ENTRADA DE DADOS
cat("Digite o tamanho do vetor: ");
n <- as.integer(readline(prompt = "")) # ATENÇÃO

cat("Digite os elementos: ")
v1 <- leiaVetor(n)
v2 <- vector(mode="integer", length=n)

# PROCESSAMENTO
for(i in 1:n){
  max <- v1[i];
  if (i-1 >= 1 && max < v1[i-1]) {
      max <- v1[i-1];
  }
  if (i+1 <= n && max < v1[i+1]) {
      max <- v1[i+1];
  }
  v2[i] <- max;
}

# SAÍDA DE DADOS
cat("v2:\n");
escrevaVetor(v2)


# Para executar SOMENTE em uma atividade no Moodle+VPL
%%writefile cap5ex04.r

leiaVetor <- function(contaLinhas,n) {
  v <- NULL
  for(i in 1:n){
    x <-  as.numeric(lines[contaLinhas]) # ATENÇÃO
    contaLinhas <- contaLinhas + 1
    v <- c(v, x)
  }
  return(v);
}

escrevaVetor <- function(v) {
  for(i in 1:length(v)){
    cat(v[i],"\n")
  }
}

con <- file("stdin")    # ATENÇÃO
lines <- readLines(con) # ATENÇÃO
contaLinhas <- 1        # ATENÇÃO

# ENTRADA DE DADOS
cat("Digite o tamanho do vetor: ");
n <- as.numeric(lines[contaLinhas]) # ATENÇÃO
contaLinhas <- contaLinhas + 1

cat("Digite os elementos: ")
v1 <- leiaVetor(contaLinhas,n)

v2 <- vector(mode="integer", length=n)

# PROCESSAMENTO
for(i in 1:n){
  max <- v1[i];
  if (i-1 >= 1 && max < v1[i-1]) {
      max <- v1[i-1];
  }
  if (i+1 <= n && max < v1[i+1]) {
      max <- v1[i+1];
  }
  v2[i] <- max;
}

# SAÍDA DE DADOS
cat("v2:\n");
escrevaVetor(v2)


%%writefile str2int.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int MAX=100, tamanho = 0;
void leiaVetor(int v[MAX], char string[]) {
   char * token = strtok(string, " ");
   while( token != NULL ) {
      v[tamanho++] = atoi(token); // converte texto para inteiro
      token = strtok(NULL, " ");
   }
}
int main() {
   char string[] = "7 3 7 9 7 7 0 9 8 4 8 9 0 1     7 8 4 1 1 0     ";
   int v[MAX];
   leiaVetor(v, string);
   for (int i=0;i<tamanho;i++ ){
     printf("%d ",v[i]);
   }
   return 0;
}


%%shell
gcc -Wall -std=c99 str2int.c -o output2
./output2


%%writefile str2int.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int tamanho = 20;
// método para ler um vetor de inteiros digitado em uma linha, separados por espaços
int* leiaVetor(int n) {
  int* v = malloc(n * sizeof(int)); // aloca um vetor de n inteiros
  char texto[512]; // espaço para todos os números como um texto
  scanf("%[^\n]", texto); // lê todos os números como um texto
  char* token = strtok(texto, " "); // lê até o primeiro espaço na variável token
  int i = 0;
  while (token != NULL && i < n) {
    v[i++] = atoi(token); // guarda o valor convertido em numero no vetor e avança
    token = strtok(NULL, " "); // lê até ao próximo espaço a partir de onde terminou
  }
  return v;
}
int main() {
   //char string[] = "7 3 7 9 7 7 0 9 8 4 8 9 0 1     7 8 4 1 1 0     ";
   int * v = leiaVetor(tamanho);
   for (int i=0;i<tamanho;i++ ){
     printf("%d ",v[i]);
   }
   free(v); // libera memória alocada com malloc
   return 0;
}


%%shell
gcc -Wall -std=c99 str2int.c -o output2
./output2


# Solicita ao usuário que insira o primeiro vetor como texto
texto1 = input("Insira o primeiro vetor: ") # copie e cole a primeira linha

# Solicita ao usuário que insira o segundo vetor como texto
texto2 = input("Insira o segundo vetor: ") # copie e cole a segunda linha

# Se não quiser utilizar input(), basta criar as variáveis como string:
# texto1 = "7 3 7 9 7 7 0 9 8 4 8 9 0 1 7 8 4 1 1 0"
# texto2 = "2 1 9 4 3 6 0 9 8 4 2 8 0 6 7 3 2 4 5 9"

# Método para ler um vetor a partir de um texto
def lerVetor(texto):
    # split cria um vetor a partir do texto
    vetSemEspaco = texto.split(' ')
    print(vetSemEspaco)  # Somente para ver o conteúdo do vetor criado

    vet = []  # Cria um vetor vazio
    for i in range(len(vetSemEspaco)):
        if vetSemEspaco[i]:  # Se tiver algum elemento diferente de ''
            # Insere inteiro no vetor
            vet.append(int(vetSemEspaco[i]))

    return vet

# Chama a função para ler os vetores a partir dos textos fornecidos
vetor1 = lerVetor(texto1)
vetor2 = lerVetor(texto2)

# Imprime os vetores resultantes
print('Vetor 1:', *vetor1)
print('Vetor 2:', *vetor2)


# Escrever o método lerVetor de forma compacta
vetor1 = [int(i) for i in texto1.split(' ') if i]
vetor2 = [int(i) for i in texto2.split(' ') if i]
print('vetor 1:',*vetor1)
print('vetor 2:',*vetor2)


texto = input() # copie e cole uma linha com texto

conta = 0
vogais = 'AEIOUaeiou'
for i in texto:
  if i in vogais:
    conta += 1
print('Número de vogais: ', conta)


x = 4.5


print(f'This will print out the variable x: {x:12}')
print(f'This will print out the variable x: {x:>12}')
print(f'This will print out the variable x: {x:>14.3f}')
print(f'This will print out the variable x: {x:=014.3f}')

print(f'\n{"="*50}')
print(f'{"My List":^50s}')
print(f'{"="*50}')


table = ['Sjoerd','Jack','Dcab']
for name in table:
  print(f'{name:>20}')

print()
table2 = [4127, 4098,  7678]
for num in table2:
  print(f'{num:10}')


print(f'Number\tSquare\tCube')
for x in range(1, 11):
  print(f'{x:2d} \t{x*x:3d} \t{x*x*x:4d}')


print(f'Number\tSquare\t\tCube')
for x in range(1, 11):
  x = float(x)
  print(f'{x:5.2f}\t{x*x:6.2f}\t{x*x*x:12.2f}')


APPLES = .50
BREAD = 1.50
CHEESE = 2.25
numApples = 3
numBread = 4
numCheese = 2
prcApples = 3 * APPLES
prcBread = 4 * BREAD
prcCheese = 2 * CHEESE
strApples = 'Apples'
strBread = 'Bread'
strCheese = 'Cheese'

total = prcBread + prcBread + prcApples
print(f'{"My Grocery List":^31s}')
print(f'{"="*31}')
print(f'{strApples}\t{numApples:10d}\tR${prcApples:>5.2f}')
print(f'{strBread}\t{numBread:10d}\tR${prcBread:>5.2f}')
print(f'{strCheese}\t{numCheese:10d}\tR${prcCheese:>5.2f}')
print(f'{"Total:":>19s}\tR${total:>5.2f}')


number = 1000000
print(f'The number, 1000000, formatted with a comma{number:,.2f}')
print(f'The number, 1000000, formatted with a comma and right-aligned in a width of 15 {number:>15,.2f}')


import numpy as np  # Muito útil para trabalhar com vetores e matrizes!

# Matriz de inteiros iniciada com zero com 3x2 elementos
m1 = [[0, 0], [0, 0], [0, 0]]

# NÃO criar matrizes dessa forma, pois pode resultar em comportamento inesperado
m2 = 3 * [2 * [0]]

# Exibe as matrizes e seus tipos
print("Matriz m1:", m1, "Tipo:", type(m1))
print("Matriz m2:", m2, "Tipo:", type(m2), "(Evite essa forma!)")


# Criação de uma lista m2 contendo 3 referências para a mesma lista [0, 0]
# Esse é um padrão comum, mas leva a problemas inesperados em Python
m2 = 3 * [2 * [0]]

# Exibe o tipo da variável m2
print("Tipo de m2:", type(m2))

# Modifica o primeiro elemento da primeira lista interna (m2[0][0])
# No entanto, todas as listas internas são referências para a mesma lista
# Portanto, a modificação afeta todas as "cópias" dessa lista
m2[0][0] = 8

# Exibe a variável m2 após a modificação
print("m2 após modificação:", m2)


# Uma abordagem alternativa que funciona
m2 = [[0] * 2 for _ in range(3)]

# Modificando o primeiro elemento da primeira linha da matriz m2
m2[0][0] = 8

# Exibindo a matriz após a modificação
print("Matriz m2:", m2)


def leiaMatriz(L, C):
    # Criando uma matriz com L linhas e C colunas
    matriz = [[0] * C for _ in range(L)]

    print("Digite os valores da matriz:")
    for i in range(L):
        for j in range(C):
            matriz[i][j] = int(input(f"Elemento [{i+1},{j+1}]: "))
    return matriz

def escrevaMatriz(m):
    # Exibindo a matriz formatada
    for i in range(len(m)):
        for j in range(len(m[0])):
            print(f"{m[i][j]:<6}", end="")  # Formatando a saída
        print()

def escrevaMatriz_v2(m):
    # Exibindo a matriz de forma mais compacta
    for i in range(len(m)):
        print(*m[i])

# ENTRADA DE DADOS
L = int(input("Digite o número de alunos: "))
C = int(input("Digite o número de avaliações: "))
C += 1  # A primeira coluna é o RA do aluno
matriz_alunos = leiaMatriz(L, C)

# PROCESSAMENTO ? (Nada foi especificado)

# SAÍDA DE DADOS
print("\nLISTA DE ALUNOS vs Avaliações:")
escrevaMatriz(matriz_alunos)


%%writefile cap6ex01.java

import java.util.Scanner;

public class cap6ex01 {

    static Scanner scan = new Scanner(System.in);

    public static void main(String[] args) {

        // ENTRADA DE DADOS
        System.out.print("Digite o numero de alunos:");
        int L = scan.nextInt();        // lê número de linhas
        System.out.print("Digite o numero de avaliações:");
        int C = scan.nextInt();        // lê número de colunas
        int m[][]; // declara

        C = C + 1; // a primeira coluna é o RA do aluno

        System.out.println("Entre com os elementos da matriz:");
        m = leiaMatriz(L,C);

        // PROCESSAMENTO: ?

        // SAÍDA DE DADOS
        System.out.print("LISTA DE ALUNOS vs Avaliações:\nRA");
        for (int i = 0; i < C-1; i++) {
            System.out.printf("%4d", i+1);
        }
        System.out.println();
        escrevaMatriz(m);
    }

    static int[][] leiaMatriz(int L, int C) {
      // leitura dos LxC elmentos da matriz m
      int m[][] = new int[L][C];
      for (int i = 0; i < m.length; i++)         // linhas i
          for (int j = 0; j < m[0].length; j++)  // coluna j
            m[i][j] = scan.nextInt();
            // lê elemento i,j
      return m;
    }

    static void escrevaMatriz(int m[][]) {
      // imprimir matriz (cada linha de m em uma linha)
      for (int i = 0; i < m.length; i++) {       // linha  i
          for (int j = 0; j < m[0].length; j++)  // coluna j
              System.out.printf("%4d", m[i][j]); // formatada
          System.out.println();                  // pula linha
      }
    }
}


!javac cap6ex01.java
!java cap6ex01


# solução 1
%%writefile cap6ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
const leia = (name) => {return `${name}`}

function leiaMatriz(L,C,contaLinhas) {
  var m = [];
  for(var i=0; i < L; i++){  // Creates all lines:
      m.push([]);  // Creates an empty line
      m[i].push( new Array(C)); // Adds cols to the empty line:
      for(var j=0; j < C; j++){
        m[i][j] = parseInt(leia(process.argv[contaLinhas])) // ATENÇÃO NESTA INSTRUÇÃO!
        contaLinhas++
      }
  }
  return m;
}
function escrevaMatriz(m) {
  s = ''
  for (i=0; i<m.length; i++) {
    for (j=0; j<m[0].length; j++) {
      s += m[i][j] + "\t";
    }
    s += "\n"
  }
  escreva(s)
}

// ENTRADAS
escreva("Digite o numero de alunos: ")
var L = parseInt(leia(process.argv[2]))    // ATENÇÃO NESTA INSTRUÇÃO!
escreva("Digite o numero de avaliações: ")
var C = parseInt(leia(process.argv[3]))    // ATENÇÃO NESTA INSTRUÇÃO!

C = C + 1; // a primeira coluna é o RA do aluno

contaLinhas = 4;  // ATENÇÃO NESTA INSTRUÇÃO!
m = leiaMatriz(L,C,contaLinhas)

// PROCESSAMENTO ?
// SAÍDA DE DADOS
escreva("LISTA DE ALUNOS vs Avaliações:");
var s = "RA"
for (i = 0; i < C-1; i++) {
  s +="\t"+(i+1)
}
escreva(s)
escrevaMatriz(m)


%%shell
node cap6ex01 2 2 2345 5 9 9834 9 7


# solução 2: para executar no Moodle+VPL
%%writefile cap6ex01.js
function escreva(s) {try {element.append(s)} catch(e) {try {document.write(s)} catch(e) {console.log(s)}}}
function leia(linhas,i) {return linhas.toString().split('\n')[i]}

function leiaMatriz(linhas,L,C,contaLinhas) {
  var m = [];
  for(var i=0; i < L; i++){  // Creates all lines:
      m.push([]);  // Creates an empty line
      m[i].push( new Array(C)); // Adds cols to the empty line:
      for(var j=0; j < C; j++){
        m[i][j] = parseInt(leia(linhas,contaLinhas)) // ATENÇÃO NESTA INSTRUÇÃO!
        contaLinhas++
      }
  }
  return m;
}
function escrevaMatriz(m) {
  s = ''
  for (i=0; i<m.length; i++) {
    for (j=0; j<m[0].length; j++) {
      s += m[i][j] + "\t";
    }
    s += "\n"
  }
  escreva(s)
}

process.stdin.once('data', linhas => {
  // ENTRADAS
  escreva("Digite o numero de alunos: ")
  var L = parseInt(leia(linhas,0))    // ATENÇÃO NESTA INSTRUÇÃO!
  escreva("Digite o numero de avaliações: ")
  var C = parseInt(leia(linhas,1))    // ATENÇÃO NESTA INSTRUÇÃO!

  C = C + 1; // a primeira coluna é o RA do aluno

  contaLinhas = 2;  // ATENÇÃO NESTA INSTRUÇÃO!
  m = leiaMatriz(linhas,L,C,contaLinhas)

  // PROCESSAMENTO ?
  // SAÍDA DE DADOS
  escreva("LISTA DE ALUNOS vs Avaliações:");
  var s = "RA"
  for (i = 0; i < C-1; i++) {
    s +="\t"+(i+1)
  }
  escreva(s)
  escrevaMatriz(m)
})


# NÃO executa NESTE COLAB, SOMENTE NO MOODLE+VPL
%%shell
#node cap6ex01 2 2 2345 5 9 9834 9 7


%%writefile cap6ex01.c
#include <stdio.h>
#include<malloc.h>

int ** leiaMatriz(int L, int C) {
  int **m = (int **)malloc(L*sizeof(int*));
  for (int i = 0; i < L; i++) {
    m[i] = (int *)malloc(C * sizeof(int)); // for each row allocate C ints
    for (int j = 0; j < C; j++)
      scanf("%d", &m[i][j]);
  }
  return m;
}
void free_matrix(int **m, int L) {
    for (int i = 0; i < L; i++)
         free(m[i]);
    free(m);
 }
void escrevaMatriz(int **m, int L, int C) {
  for (int i = 0; i < L; i++) {
   for (int j = 0; j < C; j++)
      printf("%d\t", m[i][j]);
   printf("\n");
  }
}
int main(void) {
  // ENTRADA DE DADOS
  int L, C, **m;   // variaveis de referência m
  printf("Digite o número de alunos: ");
  scanf("%d", &L);

  printf("Digite o número de avaliações: ");
  scanf("%d", &C);

  C = C + 1; // a primeira coluna é o RA do aluno

  printf("Digite os elementos da matriz");
  m = leiaMatriz(L,C);

  // PROCESSAMENTO ?

  // SAÍDA DE DADOS
  printf("\nLISTA DE ALUNOS vs Avaliações:\n");
  printf("RA ");
  for (int i = 0; i < C-1; i++)
    printf("\t%d",(i+1));

  printf("\n");
  escrevaMatriz(m,L,C);
  free_matrix(m,L); // liberar memória alocado com malloc
  return 0;
}


%%shell
gcc -Wall -std=c99 cap6ex01.c -o output2
./output2


# activate R magic
%load_ext rpy2.ipython


%%R
leiaMatriz <- function(L,C) {
  m <- matrix(0,L,C)
  for(i in 1:L){
    for(j in 1:C){
      m[i,j] <-  as.integer(readline(prompt = "")) # ATENÇÃO
    }
  }
  return(m);
}

escrevaMatriz <- function(m) {
  for(i in 1:nrow(m)) {
    for(j in 1:ncol(m)) {
      cat(m[i,j],"\t")
    }
    cat("\n")
  }
}

# ENTRADA DE DADOS
cat("Digite o número de alunos: ");
L <- as.integer(readline(prompt = "")) # ATENÇÃO

cat("Digite o número de avaliações: ");
C <- as.integer(readline(prompt = "")) # ATENÇÃO

C <- C + 1; # a primeira coluna é o RA do aluno

cat("Digite os elementos da matriz: ")
m <- leiaMatriz(L,C)

# PROCESSAMENTO: ?

# SAÍDA DE DADOS
cat("LISTA DE ALUNOS vs Avaliações:\n");
cat("RA");
for (i in 1:(C-1)) {
  cat("\t",i);
}
cat("\n");
escrevaMatriz(m)


# Para executar SOMENTE em uma atividade no Moodle+VPL
%%writefile cap6ex01.r

leiaMatriz <- function(contaLinhas,L,C) {
  m <- matrix(0,L,C)
  for(i in 1:L){
    for(j in 1:C){
      m[i,j] <- as.numeric(lines[contaLinhas]) # ATENÇÃO
      contaLinhas <- contaLinhas + 1
    }
  }
  return(m);
}

escrevaMatriz <- function(m) {
  for(i in 1:nrow(m)) {
    for(j in 1:ncol(m)) {
      cat(m[i,j],"\t")
    }
    cat("\n")
  }
}

con <- file("stdin")    # ATENÇÃO
lines <- readLines(con) # ATENÇÃO
contaLinhas <- 1        # ATENÇÃO

# ENTRADA DE DADOS
cat("Digite o número de alunos: ");
L <- as.numeric(lines[contaLinhas]) # ATENÇÃO
contaLinhas <- contaLinhas + 1

cat("Digite o número de avaliações: ");
C <- as.numeric(lines[contaLinhas]) # ATENÇÃO
contaLinhas <- contaLinhas + 1

C <- C + 1; # a primeira coluna é o RA do aluno

cat("Digite os elementos da matriz: ")
m <- leiaMatriz(contaLinhas,L,C)

# PROCESSAMENTO: ?

# SAÍDA DE DADOS
cat("LISTA DE ALUNOS vs Avaliações:\n");
cat("RA");
for (i in 1:(C-1)) {
  cat("\t",i);
}
cat("\n");
escrevaMatriz(m)


def escrevaMatriz(m):
    # Exibindo a matriz formatada
    for i in range(len(m)):
        for j in range(len(m[0])):
            print(f"{m[i][j]:<6}", end="")  # Formatando a saída
        print()

# interessante para testar
import random
L, C = random.randint(2, 9), random.randint(2, 9)
print(f"L={L}, C={C}")
m = [[random.randint(0, 9) for _ in range(C)] for _ in range(L)]
escrevaMatriz(m)


import random

def criar_matriz_aleatoria(linhas, colunas):
    """
    Cria uma matriz com números inteiros aleatórios no intervalo de 0 a 9.

    Parâmetros:
    - linhas (int): Número de linhas na matriz.
    - colunas (int): Número de colunas na matriz.

    Retorna:
    - matriz (list): Matriz com números inteiros aleatórios.
    """
    matriz = []

    for i in range(linhas):
        linha = []
        for j in range(colunas):
            elemento = random.randint(0, 9)
            linha.append(elemento)
        matriz.append(linha)

    return matriz

# Exemplo de uso:
L, C = random.randint(2, 9), random.randint(2, 9)
print(f"L={L}, C={C}")
matriz_aleatoria = criar_matriz_aleatoria(L, C)

# Exibindo a matriz criada
escrevaMatriz(matriz_aleatoria)


def leiaMatriz():
    """
    Lê uma matriz de inteiros.

    Retorna:
    - matriz (list): Matriz de inteiros.
    """
    matriz = []
    ler_linha = input() # Digite os elementos da matriz (pressione Enter para finalizar"

    while ler_linha:
        linha = [int(i) for i in ler_linha.split(' ') if i]
        matriz.append(linha)
        ler_linha = input()

    return matriz

def escrevaMatriz(m):
    # Exibindo a matriz formatada
    for i in range(len(m)):
        for j in range(len(m[0])):
            print(f"{m[i][j]:<6}", end="")  # Formatando a saída
        print()

m1 = leiaMatriz() # tem que terminar com uma linha em branco
L = len(m1)  # Número de linhas
C = len(m1[0])  # Número de colunas (assumindo que todas as linhas têm o mesmo comprimento)
print(f"L={L}, C={C}")
escrevaMatriz(m1)


def leiaMatriz2(matrizTexto):
    """
    Lê uma matriz de inteiros a partir de uma string.

    Parâmetros:
    - matrizTexto (str): String contendo a representação da matriz.

    Retorna:
    - matriz (list): Matriz de inteiros.
    """
    matriz = []
    ler_linhas = matrizTexto.strip().split('\n')

    for linha in ler_linhas:
        if linha:  # Se a linha tiver algum conteúdo
            matriz.append([int(i) for i in linha.split(' ') if i])

    return matriz

def escrevaMatriz(matriz):
    """
    Exibe a matriz.

    Parâmetros:
    - matriz (list): Matriz a ser exibida.
    """
    for linha in matriz:
        print(*linha)

matrizTexto = '''
0 9 3 6 9 8 4 5 4
8 1 2 3 5 2 9 9 6
4 1 1 0 9 9 8 2 7
5 2 8 4 6 6 0 8 0
4 7 6 4 3 9 3 3 5
2 6 0 4 0 7 5 5 2
9 8 4 8 4 7 1 4 3
'''

m1 = leiaMatriz2(matrizTexto)
L = len(m1)
C = len(m1[0])  # Obtendo o número de colunas, assumindo que todas as linhas têm o mesmo comprimento
print(f"L={L}, C={C}")
escrevaMatriz(m1)


import numpy as np
def escreverMatriz(m): # escreve matriz, linha por linha
  for linha in m:
    print(*linha)

L,C = np.random.randint(2,10, size = 2) # INTERESSANTE para testar
print(L,C)
m = np.random.randint(10, size=(L,C))   # INTERESSANTE para testar
escreverMatriz(m)


def lerMatriz(): # ler matriz de inteiros
  m, ler_linha = [], input()
  while ler_linha:
    m.append([int(i) for i in ler_linha.split(' ') if i])
    ler_linha = input()
  return np.array(m, dtype=int)

m1 = lerMatriz()
L,C = m1.shape # para ler as dimensões de uma matriz no numpy
print(L,C)
escreverMatriz(m1)


# escreva o seu código
def calcMedia(m):
  v = []
  L, C = m.shape
  m1 = np.zeros((L,C+1), dtype=float)
  for i in range(L): # para cada linha/aluno
    soma = 0
    for j in range(C): # para cada coluna/nota do aluno
      soma += m[i,j]
      m1[i,j] = m[i,j]
    m1[i,C] = round(soma / C,2)
  return m1

escreverMatriz(m)
print()
escreverMatriz(calcMedia(m))


import numpy as np # muito útil para trabalhar com vetor!

def lerMatriz2(L,C):
  m = np.zeros((L,C)).astype(int) # matriz de inteiro com Linhas x Colunas
  for i in range(L):
    for j in range(C):
      m[i][j] = int(input())
  return m

# ENTRADA DE DADOS
L = int(input("Digite o numero de alunos:"))
C = int(input("Digite o numero de avaliações:"))
m = lerMatriz2(L,C)
# PROCESSAMENTO ?
m1 = calcMedia(m)

# SAÍDA DE DADOS
escreverMatriz(m1)


%%writefile cap7ex01.c
#include <stdio.h>
#include <string.h>

struct TAluno {
  char nome[50];
  int idade;
  char rua[50];
  int numero;
};

int main() {
  struct TAluno ana; // instancia uma variável c do tipo TAluno
  // ENTRADA DE DADOS
  strcpy(ana.nome, "Ana Silva");
  ana.idade = 18;
  strcpy(ana.rua, "Avenida Paulista");
  ana.numero = 1000;

  // SAÍDA DE DADOS
  printf("nome: %s\nidade: %d\n", ana.nome, ana.idade);
  printf("rua: %s\nnúmero: %d\n", ana.rua, ana.numero);
  return 0;
}


%%shell
gcc -Wall -std=c99 cap7ex01.c -o output
./output


%%writefile cap7ex02.c
#include <stdio.h>
#include <string.h>

struct TAluno {
  char nome[50];
  int idade;
  char rua[50];
  int numero;
};

int main() {
  struct TAluno Alunos[2]; // instancia uma vetor do tipo TAluno
  // ENTRADA DE DADOS
  for (int i = 0; i < 2; i++) {
    printf("Entre com os dados: nome, idade, rua, número:\n");
    fflush(stdin);
    fgets(Alunos[i].nome, 50, stdin);
    scanf("%d", &Alunos[i].idade);
    fflush(stdin);
    fgets(Alunos[i].rua, 50, stdin);
    scanf("%d", &Alunos[i].numero);
  }
  // SAÍDA DE DADOS
  for (int i = 0; i < 2; i++) {
    printf("nome: %s\nidade: %d\n", Alunos[i].nome, Alunos[i].idade);
    printf("rua: %s\nnúmero: %d\n", Alunos[i].rua, Alunos[i].numero);
  }
  return 0;
}


%%shell
gcc -Wall -std=c99 cap7ex02.c -o output
./output


%%writefile cap7ex03.c
#include <stdio.h>
#include <string.h>

struct TAluno {
  char nome[50];
  int idade;
  char rua[50];
  int numero;
};

typedef struct TAluno Aluno;

int main() {
  // ENTRADA DE DADOS
  Aluno Ana = { "Ana Silva" , 18, "Avenida Paulista" , 1000 };

  // SAÍDA DE DADOS
  printf("%s %d %s %d", Ana.nome, Ana.idade, Ana.rua, Ana.numero);
  return 0;
}


%%shell
gcc -Wall -std=c99 cap7ex03.c -o output
./output


%%writefile cap7ex04.c
#include <stdio.h>
#include <string.h>

typedef struct TAluno {
  char nome[50];
  int idade;
  char rua[50];
  int numero;
} Aluno;

int main() {
  // ENTRADA DE DADOS
  Aluno ana = { "Ana Silva" , 18, "Avenida Paulista" , 1000 };

  // SAÍDA DE DADOS
  printf("%s %d %s %d", ana.nome, ana.idade, ana.rua, ana.numero);
  return 0;
}


%%shell
gcc -Wall -std=c99 cap7ex04.c -o output
./output


%%writefile cap7ex05.c
#include <stdio.h>
#include <string.h>

typedef struct {
  char rua[50];
  int numero;
} Endereco;

typedef struct {
  char nome[50];
  int idade;
  Endereco end;
} Cliente;

void leiaCliente(Cliente* cliente) {
  fflush(stdin);
  printf("nome: ");
  fgets((*cliente).nome, 50, stdin);
  printf("idade: ");
  scanf("%d", &(*cliente).idade);
  fflush(stdin);
  printf("rua: ");
  fgets((*cliente).end.rua, 50, stdin);
  printf("numero: ");
  scanf("%d", &(*cliente).end.numero);
}

void escrevaCliente(Cliente cliente) {
  printf("nome: %s\nidade: %d\n", cliente.nome, cliente.idade);
  printf("rua: %s\nnumero: %d\n", cliente.end.rua, cliente.end.numero);
}

int main() {
  Cliente clientes[2];
  // ENTRADA DE DADOS
  for (int i = 0; i < 2; i++) {
    printf("Cadastrar dados do cliente %d\n", i + 1);
    leiaCliente(&clientes[i]);
  }

  // SAÍDA DE DADOS
  for (int i = 0; i < 2; i++) {
    printf("Imprimir dados do cliente %d\n", i + 1);
    escrevaCliente(clientes[i]);
  }
  return 0;
}


%%shell
gcc -Wall -std=c99 cap7ex05.c -o output
./output


%%writefile cap7ex06.c
#include "myBiblioteca.h"

int main() {
  Cliente clientes[2];
  // ENTRADA DE DADOS
  for (int i = 0; i < 2; i++) {
    printf("Cadastrar dados do cliente %d\n", i + 1);
    leiaCliente(&clientes[i]);
  }

  // SAÍDA DE DADOS
  for (int i = 0; i < 2; i++) {
    printf("Imprimir dados do cliente %d\n", i + 1);
    escrevaCliente(clientes[i]);
  }
  return 0;
}


%%writefile myBiblioteca.h
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct {
  char rua[50];
  int numero;
} Endereco;

typedef struct {
  char nome[50];
  int idade;
  Endereco end;
} Cliente;

void leiaCliente(Cliente* cliente);
void escrevaCliente(Cliente cliente);


%%writefile myBiblioteca.c
#include "myBiblioteca.h"

void escrevaCliente(Cliente cliente) {
  printf("nome: %s\nidade: %d\n", cliente.nome, cliente.idade);
  printf("rua: %s\nnúmero: %d\n", cliente.end.rua, cliente.end.numero);
}

// leia um cliente a partir do teclado
// nome, idade, rua, numero
void leiaCliente(Cliente* cliente) {
  fflush(stdin);
  printf("nome: ");
  fgets((*cliente).nome, 50, stdin);
  printf("idade: ");
  scanf("%d", &(*cliente).idade);
  fflush(stdin);
  printf("rua: ");
  fgets((*cliente).end.rua, 50, stdin);
  printf("numero: ");
  scanf("%d", &(*cliente).end.numero);
}


%%shell
gcc -Wall -std=c99 cap7ex06.c myBiblioteca.c -o output
./output


%%writefile cap7ex07.c
#include <stdio.h>

int main() {
  char* filename = "teste.txt";
  FILE* file;

  file = fopen(filename, "w"); // Cria arquivo para escrita
  if (file == NULL) {
    printf("Erro ao abrir o arquivo: %s\n", filename);
    return -1;
  }

  // SAÍDA DE DADOS
  for (int i = 0; i < 10; i++)
    fprintf(file, "Linha %02d\n", i + 1); // Escrever algo no arquivo

  fclose(file); // fecha arquivo
  return 0;
}


%%shell
gcc -Wall -std=c99 cap7ex07.c -o output
./output
cat teste.txt


%%writefile cap7ex08.c
#include <stdio.h>

int main() {
  char* filename = "teste.txt", ch;
  FILE* file;

  // ENTRADA DE DADOS
  file = fopen(filename, "r"); // Cria arquivo para leitura
  if (file == NULL) {
    printf("Erro ao abrir o arquivo: %s\n", filename);
    return -1;
  }

  // SAÍDA DE DADOS
  while ((ch = fgetc(file)) != EOF) { // Lê arquivo
    printf("%c", ch); // caracter por caracter
  }

  fclose(file); // fecha arquivo
  return 0;
}


%%shell
gcc -Wall -std=c99 cap7ex08.c -o output
./output


%%writefile dados.csv
Maria Souza, 19, Avenida Paulista, 1000
Pedro Silva, 18, Avenida Rebouças, 2500


%%writefile cap7ex09.c
#include "myBiblioteca.h"

int main() {
  Cliente clientes[20];
  char* filename = "dados.csv";

  // ENTRADA DE DADOS
  FILE* file; // Cria arquivo para leitura
  if ((file = fopen(filename, "r")) == NULL) {
    printf("Erro ao abrir o arquivo: %s\n", filename);
    return -1;
  }

  int contador = 0;
  char linha[512]; // espaço para cada linha lida
  while (fgets(linha, sizeof(linha), file))  // para cada linha
    criaCliente(&clientes[contador++], linha);

  // SAÍDA DE DADOS
  for (int i = 0; i < contador; i++) {
    printf("\nImprimir dados do cliente %d\n", i + 1);
    escrevaCliente(clientes[i]);
  }

  fclose(file); // fecha arquivo
  return 0;
}


%%writefile myBiblioteca.h
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct {
  char rua[50];
  int numero;
} Endereco;

typedef struct {
  char nome[50];
  int idade;
  Endereco end;
} Cliente;

void leiaCliente(Cliente* cliente);
void escrevaCliente(Cliente cliente);
void criaCliente(Cliente* cliente, char linha[512]);


%%writefile myBiblioteca.c
#include "myBiblioteca.h"
// cria um cliente a partir de uma linha de texto. Exemplo:
// "Maria Souza, 20, Avenida Paulista, 1200"
void criaCliente(Cliente* cliente, char linha[512]) {
  // Ler nome
  char* token = strtok(linha, ","); // ler até a primeira ","
  strcpy((*cliente).nome, token); // nome

  // Ler idade
  token = strtok(NULL, ","); // continar lendo até a próxima ","
  (*cliente).idade = atoi(token); // converter str to int

  // Ler rua
  token = strtok(NULL, ",");
  strcpy((*cliente).end.rua, token + 1); // +1 retira 1o espaço em branco

  // Ler numero
  token = strtok(NULL, ",");
  (*cliente).end.numero = atoi(token); // converter str to int
}
void escrevaCliente(Cliente cliente) {
  printf("nome: %s\nidade: %d\n", cliente.nome, cliente.idade);
  printf("rua: %s\nnúmero: %d\n", cliente.end.rua, cliente.end.numero);
}

// leia um cliente a partir do teclado
// nome, idade, rua, numero
void leiaCliente(Cliente* cliente) {
  fflush(stdin);
  printf("nome: ");
  fgets((*cliente).nome, 50, stdin);
  printf("idade: ");
  scanf("%d", &(*cliente).idade);
  fflush(stdin);
  printf("rua: ");
  fgets((*cliente).end.rua, 50, stdin);
  printf("numero: ");
  scanf("%d", &(*cliente).end.numero);
}


%%shell
gcc -Wall -std=c99 cap7ex09.c myBiblioteca.c -o output
./output


%%writefile cap8ex01.c
#include <stdio.h>
#include <string.h>

typedef struct {
  char nome[50];
  int idade;
  char rua[50];
  int numero;
} Aluno;

int main() {
  Aluno Alunos[2]; // instancia uma vetor do tipo Aluno
  Aluno *p; // cria um ponteiro para Aluno
  p = Alunos; // ATENÇÃO: associa p a array de alunos
  // ENTRADA DE DADOS
  for (int i = 0; i < 2; i++) {
    printf("Entre com os dados: nome, idade, rua, número:\n");
    fflush(stdin);
    fgets(p[i].nome, 50, stdin);
    scanf("%d", &p[i].idade);
    fflush(stdin);
    fgets(p[i].rua, 50, stdin);
    scanf("%d", &p[i].numero);
  }
  // SAÍDA DE DADOS
  for (int i = 0; i < 2; i++) {
    printf("nome: %s\nidade: %d\n", p[i].nome, p[i].idade);
    printf("rua: %s\nnúmero: %d\n", p[i].rua, p[i].numero);
  }
  return 0;
}


%%shell
gcc -Wall -std=c99 cap8ex01.c -o output
./output


%%writefile cap8ex02.c
#include <stdio.h>
#include<malloc.h>

int ** leiaMatriz(int L, int C) {
  int **m = (int **)malloc(L*sizeof(int*));
  for (int i = 0; i < L; i++) {
    m[i] = (int *)malloc(C * sizeof(int)); // for each row allocate C ints
    for (int j = 0; j < C; j++)
      scanf("%d", &m[i][j]);
  }
  return m;
}
void free_matrix(int **m, int L) {
    for (int i = 0; i < L; i++)
         free(m[i]);
    free(m);
 }
void escrevaMatriz(int **m, int L, int C) {
  for (int i = 0; i < L; i++) {
   for (int j = 0; j < C; j++)
      printf("%d\t", m[i][j]);
   printf("\n");
  }
}
int main(void) {
  // ENTRADA DE DADOS
  int L, C, **m;   // variaveis de referência m
  printf("Digite o número de alunos: ");
  scanf("%d", &L);

  printf("Digite o número de avaliações: ");
  scanf("%d", &C);

  C = C + 1; // a primeira coluna é o RA do aluno

  printf("Digite os elementos da matriz");
  m = leiaMatriz(L,C);

  // PROCESSAMENTO ?

  // SAÍDA DE DADOS
  printf("\nLISTA DE ALUNOS vs Avaliações:\n");
  printf("RA ");
  for (int i = 0; i < C-1; i++)
    printf("\t%d",(i+1));

  printf("\n");
  escrevaMatriz(m,L,C);
  free_matrix(m,L); // liberar memória alocado com malloc
  return 0;
}


%%shell
gcc -Wall -std=c99 cap8ex02.c -o output
./output


%%writefile myLista.h
#include <stdio.h>
#include <stdlib.h>

typedef struct TCelula Celula;
struct TCelula {
  int conteudo;
  Celula* prox;
};
Celula* lista_cria(void);
void lista_insere(Celula* p, int conteudo);
void lista_imprime(Celula* cabeca);
void lista_free(Celula* cabeca);
void lista_remove(Celula* p);
void lista_busca_remove(Celula* cabeca, int conteudo);
void lista_busca_insere(Celula* cabeca, int busca, int novo);


%%writefile myLista.c
#include "myLista.h"
Celula* lista_cria(void) {
  Celula* cabeca = (Celula*)malloc(sizeof(Celula));
  if (cabeca == NULL) {
    printf("ERRO: sem memoria\n");
    exit(1);
  }
  cabeca->prox = NULL;
  return cabeca;
}
void lista_insere(Celula* p, int conteudo) {
  // insere numa posicao p qualquer da lista
  if (p == NULL) exit(1);
  Celula* novo = (Celula*)malloc(sizeof(Celula));
  novo->conteudo = conteudo;
  novo->prox = p->prox;
  p->prox = novo;
}
void lista_free(Celula* cabeca) {
  if (cabeca == NULL) exit(1);
  Celula* aux = cabeca->prox;
  while (aux != NULL) {
    Celula* no = aux;
    aux = aux->prox;
    free(no);
  }
  free(cabeca);
}
void lista_imprime(Celula* cabeca) {
  Celula* p;
  for (p = cabeca->prox; p != NULL; p = p->prox)
    printf("%d ", p->conteudo);
  printf("\n");
}
void lista_remove(Celula* p) { // remove p->prox
  if (p == NULL) exit(1);
  Celula* no;
  no = p->prox;
  p->prox = no->prox;
  free(no);
}
void lista_busca_remove(Celula* cabeca, int conteudo) {
  if (cabeca == NULL) exit(1);
  Celula* no, * antes;
  antes = cabeca;
  no = antes->prox;
  while (no != NULL && no->conteudo != conteudo) {
    antes = no;
    no = no->prox;
  }
  lista_remove(antes);
}
void lista_busca_insere(Celula* cabeca, int busca, int novo) {
  // insere antes da primeira ocorrencia de busca ou no final
  if (cabeca == NULL) exit(1);
  Celula* no, * antes;
  antes = cabeca;
  no = antes->prox;
  while (no != NULL && no->conteudo != busca) {
    antes = no;
    no = no->prox;
  }
  lista_insere(antes, novo);
}


%%writefile cap8ex03.c
#include "myLista.h"
int main() {
  Celula* cabeca = lista_cria();
  for (int i = 0; i < 6; i++)
    lista_insere(cabeca, i + 1);
  lista_imprime(cabeca);
  lista_remove(cabeca);
  lista_imprime(cabeca);
  lista_busca_remove(cabeca, 3);
  lista_imprime(cabeca);
  lista_busca_insere(cabeca, 2, 8);
  lista_imprime(cabeca);
  lista_free(cabeca);
  return 0;
}


%%shell
gcc -Wall -std=c99 myLista.c cap8ex03.c -o output
./output


%%writefile myFila.h
#include <stdio.h>
#include <stdlib.h>

#define MAX 6
typedef struct TCelula Celula;
struct TCelula {
  int conteudo;
  Celula* prox;
};
typedef struct TFila Fila;
struct TFila {
  Celula* inicio;
  Celula* final;
};
//////////////////// Versão ***SEM*** PONTEIRO DE PONTEIRO
Fila* fila_cria(void);
void fila_free(Fila* fila);
void fila_imprime(Fila* fila);
void fila_insere(Fila* fila, int conteudo);
void fila_remove(Fila* fila);


%%writefile myFila.c
#include "myFila.h"
//////////////////// Versão 2 - ***SEM*** PONTEIRO DE PONTEIRO
Fila* fila_cria(void) {
  Fila* f = (Fila*)malloc(sizeof(Fila));
  f->inicio = f->final = NULL;
  return f;
}
void fila_insere(Fila* fila, int conteudo) {
  Celula* novo = (Celula*)malloc(sizeof(Celula));
  novo->conteudo = conteudo;
  novo->prox = fila->final;
  if (fila->inicio == NULL)
    fila->inicio = novo;
  fila->final = novo;
}
void fila_imprime(Fila* fila) {
  for (Celula* p = fila->final; p != NULL; p = p->prox)
    printf("%d ", p->conteudo);
  printf("\n");
}
void fila_free(Fila* fila) {
  if (fila == NULL) exit(1);
  Celula* aux = fila->final;
  while (aux != fila->inicio) {
    Celula* no = aux;
    aux = aux->prox;
    free(no);
  }
  free(fila);
}
void fila_remove(Fila* fila) { // remove p->prox
  Celula* ant = fila->final;
  while (ant->prox != fila->inicio)
    ant = ant->prox;
  ant->prox = NULL;
  free(fila->inicio);
  fila->inicio = ant;
}


%%writefile cap8ex04.c
#include "myFila.h"
int main() {
  Fila* fila = fila_cria();

  for (int i = 0; i < MAX; i++)
    fila_insere(fila, i + 1);
  fila_imprime(fila);
  fila_remove(fila);
  fila_imprime(fila);
  fila_remove(fila);
  fila_imprime(fila);
  fila_free(fila);
  return 0;
}


%%shell
gcc -Wall -std=c99 myFila.c cap8ex04.c -o output
./output


%%writefile myPilha.h
#include <stdio.h>
#include <stdlib.h>

#define MAX 6
typedef struct TCelula Celula;
struct TCelula {
  int conteudo;
  Celula* prox;
};
Celula* Pilha;

//////////////////// Versão ***SEM*** PONTEIRO DE PONTEIRO
Celula* pilha_cria(void);
void pilha_free(Celula* pilha);
void pilha_imprime(Celula* pilha);
void pilha_insere(Celula* pilha, int conteudo);
void pilha_remove(Celula* pilha);


%%writefile myPilha.c
#include "myPilha.h"
//////////////////// Versão 2 - ***SEM*** PONTEIRO DE PONTEIRO
// ref. https://www.ime.usp.br/~pf/algoritmos/aulas/lista.html
Celula* pilha_cria(void) {
  Celula* cabeca = (Celula*)malloc(sizeof(Celula));
  if (cabeca == NULL) {
    printf("ERRO: sem memoria\n");
    exit(1);
  }
  cabeca->prox = NULL;
  return cabeca;
}
void pilha_insere(Celula* pilha, int conteudo) {
  if (pilha == NULL) exit(1);
  Celula* novo = (Celula*)malloc(sizeof(Celula));
  novo->conteudo = conteudo;
  novo->prox = pilha->prox;
  pilha->prox = novo;
}
void pilha_imprime(Celula* pilha) {
  for (Celula* p = pilha->prox; p != NULL; p = p->prox)
    printf("%d ", p->conteudo);
  printf("\n");
}
void pilha_free(Celula* pilha) {
  if (pilha == NULL) exit(1);
  Celula* aux = pilha->prox;
  while (aux != NULL) {
    Celula* no = aux;
    aux = aux->prox;
    free(no);
  }
  free(pilha);
}
void pilha_remove(Celula* pilha) { // remove p->prox
  if (pilha == NULL) exit(1);
  Celula* no;
  no = pilha->prox;
  pilha->prox = no->prox;
  free(no);
}


%%writefile cap8ex05.c
#include "myPilha.h"
int main() {
  Celula* pilha = pilha_cria();

  for (int i = 0; i < MAX; i++)
    pilha_insere(pilha, i + 1);
  pilha_imprime(pilha);
  pilha_remove(pilha);
  pilha_imprime(pilha);
  pilha_remove(pilha);
  pilha_imprime(pilha);
  pilha_free(pilha);
  return 0;
}


%%shell
gcc -Wall -std=c99 myPilha.c cap8ex05.c -o output
./output

Válido	Inválido
idade4	4idade
Nome_Completo	Nome Completo
resta_um	resta-um
V8S9F0D7S7D9	V@R!V&+	A-B=D

operador	descrição
+	soma com
-	subtração por
*	multiplicação por
/	divisão por
//	divisão truncando a parte fracionária
%	resto da divisão por
+= x	incremento de x
-= x	decremento de y
/= x	divisão por x
**= x	exponenciação por x
%= x	resto da divisão por x
**	exponenciação
abs(x)	valor absoluto de x
pow(x,y)	igual a x**y
round(x,d)	x com d casas decimais

operador	descrição
+	soma com
-	subtração por
*	multiplicação por
/	divisão por
%	resto da divisão por
++	incremento
--	decremento

operador	descrição
+	soma com
-	subtração por
*	multiplicação por
/	divisão por
^	potência
:	operador de sequência

operador	descrição
==	é igual a
!=	é diferente de
>	é maior que
<	é menor que
>=	é maior ou igual a
<=	é menor ou igual a
x in X	x está em X?
x not in X	x não está em X?

operador	descrição
x and y	True se ambos também forem
x or y	False se ambos também forem
not x	contrário de x

operador	descrição
x && y	True se ambos também forem
x & y	True se ambos também forem bit-a-bit
x \|\| y	False se ambos também forem
x \| y	False se ambos também forem bit-a-bit
! x	contrário de x
~ x	contrário de x bit-a-bit
^ x	ou exclusivo `XOR` bit-a-bit
<<N	shift-left, adiciona N zeros à direita do número binário
<<N	shift-right, elimina N zeros à direita do número binário

operador	descrição
=	recebe o valor de
+=	é somado ao valor de
-=	é subtraído do valor de
*=	é multiplicado pelo valor de
/=	é dividido pelo valor de
%=	recebe o resto da divisão por
similarmente	>>=, <<=, &=,	=, ^=

operador	descrição
<-	recebe o valor da direita
->	recebe o valor da esquerda
assign("x",11)	x recebe o valor 11

Categoria	Operador	Associatividade
Pós-fixado	() (parênteses, operador ponto)	$\rightarrow$ Esquerda para a direita
Índice	[]	$\rightarrow$ Esquerda para a direita
Unário	++ - - ! ~ (incremento, decremento)	$\leftarrow$ Direita para a esquerda
Multiplicativo	* / % (vezes, dividido, resto)	$\rightarrow$ Esquerda para a direita
Aditivo	+ - (soma, subtração)	$\rightarrow$ Esquerda para a direita
Shift binário	>> >>> <<	$\rightarrow$ Esquerda para a direita
Relacional	> >= < <=	$\rightarrow$ Esquerda para a direita
Igualdade	== != (é igual a, é diferente de)	$\rightarrow$ Esquerda para a direita
E (AND) bit-a-bit	&	$\rightarrow$ Esquerda para a direita
XOR bit-a-bit	^	$\rightarrow$ Esquerda para a direita
Ou (OR) bit-a-bit	\|	$\rightarrow$ Esquerda para a direita
E lógico	&&	$\rightarrow$ Esquerda para a direita
Ou lógico	\|\|	$\rightarrow$ Esquerda para a direita
Condicional	?:	$\leftarrow$ Direita para a esquerda
Atribuição	= += -= *= /= %= >>= <<= &= ^= \|=	$\leftarrow$ Direita para a esquerda

operador	descrição
int	inteiro
float	ponto flutuante
bool	booleano
complex	complexo
str	texto

operador	descrição
integer	inteiro
numeric/double	ponto flutuante
logical	booleano
complex	complexo
character	texto


Tipo	Descrição	n. Bits	Mínimo	Máximo ( valor )

Tipos inteiros+sinal
byte	inteiro de 1 byte	$8$	$-128$	$127$
short	inteiro curto	$16$	$-2^{15}$	$2^{15}-1$
int	inteiro	$32$	$-2^{31}$	$2^{31}-1$
long	inteiro longo	$64$	$-2^{63}$	$2^{63}-1$

Tipos reais+ponto flut.
float	precisão simples	$32$	$2^{-149}$	$(2-2^{-23})2^{127}$
double	precisão dupla	$64$	$2^{-1074}$	$(2-2^{-52}))2^{1023}$

Tipos lógicos
boolean	valor booleano	$1$	$false$	$true$

Tipos alfanuméricos
char	caractere unicode	$16$	$0$	$2^{16}-1$

Classecadeia de caract.
String	sequência n chars	$16*n$	-	-

Outras
void	variável vazia	$0$	-	-


Conversão	Método	Exemplo

		C/C++/Java
float $\rightarrow$ int	Type cast	`int i = (int) varFloat;`
double $\rightarrow$ float	Type cast	`float f = (float) varDouble;`
float, int $\rightarrow$ double	Direto	`double d = i; d = f;`
Número $\rightarrow$ String	(Java) direto (C) stdlib.h	`String str = "" + f; str = snprintf(num);`
String $\rightarrow$ int	(Java) parse (C) stdlib.h	`i = Integer.parseInt(str); i = atoi(str);`
String $\rightarrow$ float	(Java) parse (C) stdlib.h	`f = Float.parseFloat(str);f = atof(str);`
String $\rightarrow$ double	(Java) parse (C) stdlib.h	`d = Double.parseDouble(str);d = strtod(str, NULL);`

		JavaScript
String $\rightarrow$ int	Parse	`var i = parseInt(str);`
String $\rightarrow$ float	Parse	`var f = parseFloat(str);`
Número $\rightarrow$ String	toString()	`var str = toString(f);`

código	c	f	ano	idd
`c = 1`	1
`f = 22`		22
`ano = 1994`			1994
`idd = 0`				0
`ano=ano+idd`			1994
`idd *= f`				0
`c += 1`	2
`ano+=f`			2016
`f -= 4`		18
`c += 1`	3

Tabela. Identificadores de comentário.
Linguagem	Uma linha	Várias linhas
Java/JS/C/C++	//...	/.../
Python	#...	"""...""" ou '''...'''
Matlab	%...	%{...}%
Pascal	{...}	{...}
SQL	--...	/.../
R	#..

função	descrição
strcopy(s1,s2)	copia s1 em s2
strcat(s1,s2)	copia s2 no final de s1
strlen(s)	tamanho de s
strcmp(s1,s2)	0 se s1=s2; negativo se s1<s2; positivo se s1>s2
strchr(s,ch)	ponteiro para a primeira ocorrência de ch em s
strstr(s1,s2)	ponteiro para a primeira ocorrência de s2 em s1

	Função Busca(int vet, int n, int x)	i	v[i]	Busca(v,5,1)
1	para i=0; i < n; i++	0
2	_ se v[i]==x		1
3	_ _ retorne i			0
4	retorne -1
	Valores finais			0

	Função ordena(int vet, int n)	Número de instruções por linha
1	para i=0; i < n; i++	$n$
2	_ para j=0; j < n-1; j++	$n*n$
3	_ _ se v[j] > v[j+1]	$n*n$
4	_ _ _ int aux = v[j]	$< n*n$
5	_ _ _ v[j] = v[j+1]	$< n*n$
6	_ _ _ v[j+1] = aux	$< n*n$
7	retorne v	$1$
	Complexidade	$f(n) = n*n = O(n^2)$

	Função buscaMaior(int vet, int n)	Número de instruções por linha
1	int maior = v[0]	$1$
2	para i=1; i< n; i++	$n-1$
3	_ se maior < v[i]	$n-1$
4	_ _ maior = v[i]	$< n-1$
5	retorne maior	$1$
	Complexidade	$f(n) <= 3n-1 = \Theta(n)$

	Função ordena2(int vet, int n)	Ver número de instruções por linha
1	para i=0; i < n; i++	$n-1$
2	_ para j=0; j < n-i-1; j++	$n+n-1+n-2+\cdots+1$
3	_ _ se v[j] > v[j+1]	$n+n-1+n-2+\cdots+1$
4	_ _ _ int aux = v[j]	$< n+n-1+n-2+\cdots+1$
5	_ _ _ v[j] = v[j+1]	$< n+n-1+n-2+\cdots+1$
6	_ _ _ v[j+1] = aux	$< n+n-1+n-2+\cdots+1$
7	retorne v	$1$
	Complexidade	$f(n)=n*n/2=O(n^2)$

Função	Descrição
`fopen()`	Abre arquivo
`fclose()`	Fecha arquivo
`putc()`	Escreve um caracter no arquivo
`fputc()`	Igual `putc()`
`getc()`	Lê um caracter do arquivo
`fgetc()`	Igual `getc()`
`fseek()`	Posiciona o arquivo em um determinado byte
`fprintf()`	Semelhante ao `printf()`, mas para arquivo
`fscanf()`	Semelhante ao `scanf()`, mas para arquivo
`feof()`	Verifica final de arquivo
`ferror()`	Verifica se ocorreu erro
`rewind()`	Posiciona o ponteiro para o início do arquivo
`remove()`	Apaga arquivo
`fflush()`	Descarrega o buffer do arquivo
`fgets()`	Obtém uma string do arquivo
`fread()`	Lê um bloco de dados do arquivo
`fwrite()`	Escreve um bloco de dados no arquivo
`ftell()`	Retorna a posição do ponteiro

Processando a Informação: Cap. 1: Fundamentos¶

Instruções¶

Sumário¶

Introdução à Arquitetura de Computadores¶

Algoritmos, Fluxogramas e Lógica de Programação¶

Pseudocódigo¶

Fluxogramas¶

Fluxograma a partir de código python¶

Conceitos de Linguagens de Programação¶

Níveis de Liguagens¶

Linguagem Compilada vs Interpretada¶

Estruturas de Código¶

Deburação de Código (DEBUG)¶

Ambientes de Desenvolvimento Integrados¶

Algumas Estatísticas sobre as Linguagens Mais Usadas:¶

Variáveis¶

Uso de Variáveis¶

Exemplos de variáveis do tipo inteiro:¶

Exemplo de variável do tipo texto (string)¶

Exemplo de variável do tipo real¶

Nomenclatura¶

Operadores e precedência¶

Operadores aritmeticos¶

Operadores relacionais e de conjunto¶

Operadores lógicos¶

Operadores de atribuição¶

Precedência de Operadores¶

Tipos básicos de variáveis¶

Conversões de tipos de variáveis¶

Teste de mesa¶

Aprendendo a programar¶

Salvando um arquivo¶

Exemplo 01 - Escreva 'Alô Mundo!'¶

Casos para Teste no Moodle+VPL¶

Programação sequencial¶

Entrada de dados¶

Exemplo(s) 02 - Entrada de Dados¶

Casos para Teste Moodle+VPL¶

Divisão de um código em três partes¶

Tipos de dados em C¶

Casts¶

Exercícios¶

Revisão deste capítulo de Fundamentos¶

Processando a Informação: Cap. 1: Fundamentos - Prática 1¶

Instruções¶

Sugestões para envio dos exercícios com avaliação automática no Moodle+VPL¶

Exercícios¶

Processando a Informação: Cap. 1: Fundamentos - Prática 2¶

Exercícios¶

Processando a Informação: Cap. 1: Fundamentos - Prática 4: Tutorial VSCode¶

Tuturial (em construção) VSCode¶

Processando a Informação: Cap. 2: Organização de código¶

Sumário¶

Revisão do capítulo anterior (Fundamentos)¶

Programas sequenciais¶

Comentários¶

Desvio de Fluxo¶

Programas e Subprogramas¶

Bibliotecas¶

Funções ou Métodos de Usuário¶

Exemplo 01 - Uso de Funções¶

Casos para Teste Moodle+VPL¶

Tabulação¶

Escopo¶

Reaproveitamento e Manutenção de Código¶

Exemplo 02 - Uso de Funções com Entrada e Saída de Dados¶

Casos para Teste no Moodle+VPL¶

Exercícios¶

Revisão deste capítulo de Organização de Código¶

Processando a Informação: Cap. 2: Organização de Código - Prática 1¶

Exercícios¶

Processando a Informação: Cap. 2: Organização de Código - Prática 2¶

Exercícios¶

Processando a Informação: Cap. 3: Desvios Condicionais¶

Sumário¶

Revisão do capítulo anterior (Organização de Código)¶

O que é um Desvio Condional?¶

Condições com Lógica Booleana¶

Desvios Condicionais Simples e Compostos¶

Exemplo 01 - Uso de Condicionais Simples¶

Comando `switch`¶

Exemplo 03 - Exemplo de `switch` com menu de opções¶

Formatações avançadas com `format`¶